% \section{Overview}
% \label{sec:imp-ovv}
% 
% \subsection{Column-Pages}
% \label{sec:imp-ovv-colpage}
% 
% In our parallel multi-column typesetting, a column may grow independently
% of other columns and may cross its page boundary asynchronously with
% others.  Therefore, we cannot throw away the contents of a column in a
% page, or {\em\Uidx\colpage} in short, when a page break occurs in the
% column.  Instead, we have to keep \colpage{}s until all columns are
% {\em\Uidx\sync{}ed} implicitly or explicitly.
% 
% The {\em\Uidx\imsync} takes place when all columns in a page see
% page-breaks to let the page is shipped out.  In general, all columns but
% the last one which arrives the page-break have completed \colpage{}s in the
% page in question and some of them may have succeeding \colpage{}s.
% Therefore, we maintain the list of completed \colpage{}s
% $\Uidx\S_c=|\pcol@shipped|{\cdot}c$
% 
% \SpecialArrayMainIndex{c}{\pcol@shipped}
% 
% for each column $c\In0\C$, where $\Uidx\C=\!\pcol@ncol!$ is the number of
% columns given through the argument of \env{paracol} environment, and the
% set of them $\Uidx\SS=\Set{\S_c}{c\In0\C}$.
% 
% Each element $\Uidx\s_c(p)$ of a list $\S_c$ is an \!\insert! whose
% \!\vbox! contains the 
% $p$-th completed \colpage\footnote{
% 
% Other registers such as \cs{count} are not used.},
% 
% where $p=0$ for the first \colpage{} produced in \env{paracol}
% environment or that following a page flushing macro \!\flushpage! or
% \!\clearpage!.  That is, $\S_c$ is defined as follows, where
% $\Uidx\pbase=\!\pcol@basepage!$ is the zero-origin ordinal of the
% {\em\Uidx\bpage} being the oldest page not shipped out yet.
% 
% \begin{eqnarray*}
% \S_c&=&(\s_c(\pbase),\s_c(\pbase{+}1),\ldots,\s_c(\pbase{+}k{-}1))\\
% &=&\!\@elt!\,\s_c(\pbase)\;\!\@elt!\,\s_c(\pbase{+}1)\;\cdots\;
% 	\!\@elt!\,\s_c(\pbase{+}k{-}1)
% \end{eqnarray*}
% 
% Note that a list $\S_c$ can be empty and all members $\SS$ may be empty.
% 
% The other type of \sync{}ation, {\em\Uidx\exsync}, takes place by
% \!\switchcolumn!|*| or the beginning of starred \csenv{}s, by
% \Endparacol, or by one of page flushing macros \!\flushpage! and
% \!\clearpage!.  A flushing \exsync{} ships out the pages from $\pbase$ to
% $\Uidx\ptop=\!\pcol@toppage!$ being the ordinal of the {\em\Uidx\tpage}
% to which the most advanced {\em\Uidx\lcolumn} has reached.  On the other
% hand, other non-flushing \exsync{} keeps the page $\ptop$ from being
% shipped out because the \colpage{}s in it will grow further.
% 
% 
% 
% \subsection{Current Column-Pages and Their Contexts}
% \label{sec:imp-ovv-ccol}
% 
% We also have to maintain another type of \colpage{}s which are currently
% built, or {\em\Uidx\ccolpage{}s} in short, to switch from a column to
% another.  Since each column may have its own {\em context} for the
% typsetting of it, or {\em\Uidx\cctext} in short, it were perfect to save
% the context when we leave from a 
% column and to restore that when we revisit the column if we could.
% However, \TeX{} and \LaTeX{} has a tremendously large number of context
% variables and the number become virtualy boundless when we take variables
% defined in various styles and by users themselves into account.
% Therefore, we have to abandon to keep the whole context of the column but
% carefully chose a small subset comprising variables automatically modified
% outside of users' control.  That is, the \cctext{}
% $\Uidx\cc_c=|\pcol@col|{\cdot}c$
% 
% \SpecialArrayMainIndex{c}{\pcol@col}
% 
% of a column $c$ consists of the following elements, each of which named
% $e$ is referred to as $\cc_c(e)$ hereafter.
% 
% \begin{itemize}
% \item $\Uidx\vb$
% represents $\!\insert!{\cdot}\vb$ containing the followings.
% 
% \begin{itemize}
% \item
% $\vb^b=\!\box!{\cdot}\vb=\!\@holdpg!$ is the \!\vbox! containing the main
% vertical list which has already contributed to the \ccolpage{}.
% 
% \item
% $\vb^p=\!\count!{\cdot}\vb=\!\pcol@page!$ means the \ccolpage{} belongs to
% the page $\vb^p$.
% 
% \item
% $\vb^r=\!\dimen!{\cdot}\vb=\!\@colroom!$ is the room of the column.
% \end{itemize}
% 
% \item $\Uidx\ft=\!\pcol@currfoot!$
% is the \!\insert! containing the footnotes added in the \ccolpage.  Its
% constituent \!\box!, \!\count!, \!\dimen! and \!\skip! are denoted as
% $\ft^b$, $\ft^c$, $\ft^d$, $\ft^s$ respectively.
% 
% \item $\Uidx\pd=\!\pcol@prevdepth!$
% is the depth of the last vertical item in $\vb^b$ obtained by
% \!\prevdepth!.
% 
% \item $\Uidx\tl=\!\@toplist!$
% is the list of top floats inserted in the \ccolpage.
% 
% \item $\Uidx\ml=\!\@midlist!$
% is the list of mid floats inserted in the \ccolpage.
% 
% \item $\Uidx\bl=\!\@botlist!$
% is the list of bottom floats inserted in the \ccolpage.
% 
% \item $\Uidx\dl=\!\@deferlist!$
% is the list of in-column floats deferred to the next \colpage.
% 
% \item $\Uidx\tf=\!\pcol@textfloatsep!$
% is the vertical skip replaced with \!\textfloatsep! for top floats in the
% \ccolpage{} if it has \sync{}ation points, or $\infty$ otherwise.
% 
% \item $\Uidx\fh=\!\@textfloatsheight!$
% is the total height of mid floats and their separators in the \ccolpage.
% 
% \item $\Uidx\mb=\!\@mparbottom!$
% is the bottom position of the last \!\marginpar! staff in the \ccolpage.
% 
% \item $\Uidx\tn=\!\@topnum!$
% is the maximum number of top floats which the \ccolpage{} can accommodate
% further.
% 
% \item $\Uidx\tr=\!\@toproom!$
% is the room for top floats in the \ccolpage.
% 
% \item $\Uidx\bn=\!\@botnum!$
% is the maximum number of bottom floats which the \ccolpage{} can accommodate
% further.
% 
% \item $\Uidx\br=\!\@botroom!$
% is the room for bottom floats in the \ccolpage.
%
% \item $\Uidx\cn=\!\@colnum!$
% is the maximum total number of floats which the \ccolpage{} can accommodate
% further.
% 
% \item $\Uidx\sw$
% is the following encoding of \CSIndex{if@nobreak} and
% \CSIndex{if@afterindent} at the time we left from the column $c$.
% $$
% \sw=\cases{0&$\CSIndex{if@nobreak}=\false$\cr
%            1&$\CSIndex{if@nobreak}=\true\;\land\;
%               \CSIndex{if@afterindent}=\true$\cr
%            2&$\CSIndex{if@nobreak}=\true\;\land\;
%               \CSIndex{if@afterindent}=\false$}
% $$
% Note that we have only three states because \CSIndex{if@afterindent} is
% meaningful only when $\CSIndex{if@nobreak}=\true$\footnote{
% 
% If only with the standard \LaTeX{} and so far.}.
% 
% \item $\Uidx\ep=\!\everypar!$
% is the tokens stored in \!\everypar! at the time we left from the column
% $c$.
% \end{itemize}
% 
% Note that we could add other variables to the saved context and/or provide
% some API macro to define them by users, but abandon them because it should
% be too complicated for users\footnote{
% 
% And for the author if we include save/restore of macros, though it could
% be done with a \cs{token} containing the \cs{def}initions of macros.}.
% 
% Also note that we provide a save/restore mechanism for \lcounter{}s as
% discussed in \secref{sec:imp-ovv-counter}.
% 
% 
% 
% \subsection{Pages and Their Contexts}
% \label{sec:imp-ovv-page}
% 
% Besides the \colpage{}s, we have to keep track each whole page not yet
% shipped out but has some complete or incomplete (i.e., current) \colpage{}s.
% We maintain the list;
% 
% \SpecialMainIndex{\pcol@pages}
% 
% \begin{eqnarray*}
% \Uidx\PP
% &=&\!\pcol@pages!=(\Uidx\pp(\pbase),\pp(\pbase{+}1),\ldots\pp(\ptop{-}1))\\
% &=&\!\@elt!\,\pp(\pbase)\;\!\@elt!\,\pp(\pbase{+}1)\;\cdots\;
%    \!\@elt!\,\pp(\ptop{-}1)
% \end{eqnarray*}
% 
% where $\pp(p)$ is a {\em\Uidx\pctext} of $p$ being an integer whose
% meaning is defined as follows.
% 
% \begin{itemize}
% \item $\pp(p)<0$\\
% $\pp(p)$ is equal to the (negative) value of the counter \counter{page}
% (i.e. \!\c@page!) for the page $p$, which we refer to as $\Uidx\page(p)$
% hereafter.
% 
% \item $0\leq\pp(p)<256$\\
% The page $p$ has multi-column floats or the single-column
% {\em\Uidx\preenv} preceeding \beginparacol{} in the {\em\Uidx\spage}
% where it resides and spannig all columns.  $\pp(p)=i$ represents
% $\!\insert!{\cdot}i$ for those {\em\Uidx\spanning} whose registers have
% the followings.
% 
% \begin{itemize}
% \item
% $\pp^b(p)=\!\box!{\cdot}i$ contains the \spanning.
% 
% \item
% $\pp^p(p)=\!\count!{\cdot}i=\page(p)$.
% 
% \item
% $\pp^h(p)=\!\dimen!{\cdot}i=\!\@colht!$ if positive for the height of
% columns shrunken by the \spanning.  If negative, the page is only for
% the \spanning, i.e. a {\em\Uidx\fpage}.  We use the notation $\pp^h(p)$
% for the pages $\pp(p)\notin\LBRP0{256}$ to mean \!\textheight!.
% 
% \item
% $\pp^t(p)=\!\skip!{\cdot}i=\!\pcol@topskip!$ being the value of
% \!\topskip! at \beginparacol{} to be inserted at the top of each column in
% non-first page.  Otherwise, i.e., for the columns in the \spage{}
% following the \preenv{}, it has 0 to prevent the \!\topskip! insertion.
% We use the notation $\pp^t(p)$ for the pages $\pp(p)\notin\LBRP0{256}$ to
% mean \!\pcol@topskip!.
% \end{itemize}
% 
% \item $\pp(p)\geq256$\\
% $\pp(p)=\page(p)+256$ to represent non-negative value $\page(p)$.
% \end{itemize}
% 
% The reason why we keep track of $\page(p)$ is that page numbering is not
% necessrary to be consecutive.  If such a {\em jump} occurs randomly in any
% columns explicitly updating \counter{page}, it is very tough to give a
% consistent view of the page number of a specific page to all columns.
% Therefore we suppose jumps occur only in the leftmost column 0\footnote{
% 
% But we neither inhibit nor nullify a jump in non-leftmost column and thus
% the update can be seen referring to \cs{page} counter explicitly.}
% 
% which controls the page numbering, while non-leftmost columns are expected
% to refer the \counter{page} passively.
%
% This page numbering is implemented as follows.  Each time a \colpage{} at
% $p$ of the leftmost column is completed to start a new \colpage{},
% $\page(p)$ is fixed to be the value of \counter{page} and
% $\page(q)$ represented by $\pp(q)$ for all $q\in[p,\ptop]$ are let be
% $\page(p)+(q-p)$.  This update also takes place on \cswitch{} from the
% leftmost column building a \colpage{} at $p$ to another column so that a jump
% happning before the switching is notified to other columns.  On the other
% hand, starting or \cswitch{} to a non-leftmost \colpage{} at $p$ 
% lets \counter{page} have $\page(p)$ referring to $\pp(p)$, unless
% the column starts the most advanced \tpage.  In this new \tpage{} case,
% $\pp(\ptop{+}1)$ is added to $\PP$ to represent $\page(\ptop)+1$ which
% \counter{page} is let have, and $\ptop$ is incremented.
% 
% Note that this management is imperfect because direct references of
% \counter{page} in non-leftmost columns can give inconsistent results if 
% \counter{page} is modified in a non-leftmost column or the reference occurs
% in a page $p$ after that the leftmost column modifies \counter{page} in a
% page $q$ such that $q\leq p$.  However, it is expected that the progress
% of the leftmost column usually preceeds other columns to give consistent
% \counter{page} reference even with jumps.  More importantly, it is assured
% that indirect refereces through |.aux| records and page numbers recorded
% in |.toc|, |.idx|, and so on are always consistent because of the lazy
% evaluation of \counter{page} at shipping-out of a whole page.
% 
% Also note that we also keep $\pp(\ptop)$ in \Midx{\!\pcol@currpage!}
% which is initialized by \!\pcol@output@start! to represent the \!\insert!
% for the \spanning{} preceding \beginparacol.  Then the macro is redefined
% to have the value representing the new page in \!\pcol@startpage!, by
% itself or \!\pcol@setordpage! invoked from the macro, to start the
% page\footnote{
% 
% Other \!\def!initions of \!\pcol@currpage! in \!\pcol@setpnoelt!,
% \!\pcol@output@start!, and \!\pcol@freshpage! are for coding trick and
% thus not for giving a really new \!\def!initions.}.
% 
% We denote the concatenation of $\PP$ and $\pp(\ptop)$ as $\Uidx\PPP$ to
% represent all pages {\em on-the-fly}.
% 
% 
% 
% \subsection{Counters}
% \label{sec:imp-ovv-counter}
% 
% Besides the context variables discussed in \secref{sec:imp-ovv-ccol}, we
% need to make counters local to each column except for those declared to be
% global by \!\globalcounter!.  Let $\Uidx\CC$ be the set (list) of all
% counters declared before \beginparacol, i.e., $\CC=\!\cl@@ckpt!$, and
% $$
% \Uidx\CG=\!\pcol@gcounters!=\{\Uidx\cg_1,\ldots\}=\!\@elt!|{|\cg_1|}|\cdots
% $$
% be the set of {\em\Uidx\gcounter{}s} which have declared so by
% \!\globalcounter!|{|$\cg_i$|}|.  Then the set of {\em\Uidx\lcounter{}s}
% $\Uidx\CL$ is defined as follows.
% 
% \SpecialMainIndex{\pcol@counters}
% $$
% \CL=\CC-\CG=\!\pcol@counters!=\{\Uidx\cl_1,\ldots\}=\!\@elt!|{|\cl_1|}|\cdots
% $$
% 
% Since each column has its own values in \lcounter{}s, we have to keep the
% set of counter\slash value pairs
% 
% \SpecialArrayMainIndex{c}{\pcol@counters}
% $$
% \Uidx\Cc_c=\!\pcol@counters!{\cdot}c=\{\<\cl_1,\val_c(\cl_1)\>,\ldots\}
% =\!\@elt!|{|\cl_1|}||{|\val_c(\cl_1)|}|\cdots
% $$
% for each column $c$, where $\Uidx\val_c(\cl_i)$ is the value of a counter
% $\cl_i$ local to $c$.  That is, whenever we switch from a column $c$ to
% $d$, we save $\<\cl_i,\val_c(\cl_i)\>$ in $\Cc_c$ and restore $\cl_i$ for
% $d$ by letting it have $\val_d(\cl_i)$ in $\Cc_d$, for all $\cl_i\in\CL$.
% 
% A \gcounter is free from these save\slash restore operations but needs
% another special operation when it is incremented by \!\stepcounter!.  That
% is, the invocation of \!\stepcounter! for a \gcounter{} $\cg_i$ may clear
% \lcounter{}s in its set of descendant counters
% $\Uidx\clist(\cg_i)=|\pcol@cl@|{\cdot}\cg_i$
% 
% \SpecialArrayMainIndex{\theta}{\pcol@cl@}
% 
% and this clearing must be performed on the all instances of
% $\cl_j\in\clist(\cg_i)$ saved in $\Cc_c$ for all $c\In0\C$.  Therefore, on
% the \!\stepcounter!, we do the followings for all $c\In0\C$; temporarily
% restore all $\cl_k\in\CL$ from $\Cc_c$; clear all $\cl_j\in\clist(\cg_i)$;
% and then save $\<\cl_k,\val_c(\cl_k)\>$ back to $\Cc_c$.
% 
% The other item we maintain for a \lcounter{} $\cl$ is its {\em\Uidx\lrep}
% $\arg{rep}$ in a column $c$ defined by
% $\!\definethecounter!\<\cl\>\<c\>\arg{rep}$.  The \lrep{} $\arg{rep}$ is
% kept in $|\pcol@thectr@|{\cdot}\cl{\cdot}c$ and is made \!\let!-equal to
% $|\the|{\cdot}\cl$ when the column $c$ is visted.
% 
% \SpecialArrayMainIndex{\theta{\cdot}c}{\pcol@thectr@}
% \SpecialArrayIndex{\theta}{\the}
% 
% 
% 
% \section{Interaction with \TeX{} and \LaTeX{}}
% \label{sec:imp-tex}
% 
% The macros of \Paracol{} interacts with \TeX{} and \LaTeX{} through
% various registers and macros as discussed in this section.
% 
% \subsection{Registers}
% \label{sec:imp-tex-reg}
% 
% \subsubsection{Insertion Registers}
% 
% \begin{description}
% \item[\Uidx{\!\footins!}]
% has footnotes \!\insert!ed in a page by \!\footnote! and \!\footnotetext!.
% The register is referred to by \!\pcol@makenormalcol! to combine footnotes
% to other \preenv{} to make a \spanning, and by \!\pcol@output@switch!
% to save it in $\cc_c(\ft)$ when we leave from the column $c$.  The macro
% \!\pcol@restartcolumn! restores $\cc_d(\ft)$ to the register by
% \!\pcol@getcurrfoot! and then \!\insert!s the contents of
% \!\box!\!\footins! into itself so that it contributes to the main vertical
% list to be rebuilt for the column $d$.
% 
% \item[\rm\Uidx{\!\bx@A!}, \ldots, \Uidx{\!\bx@R!}]
% have floats created by \!\@xfloat! in the ordinary usage of \LaTeX.  In
% addtion to it, we use these registers to save \preenv{}
% (\!\pcol@output@start!), completed \colpage{}s (\!\pcol@opcol!),
% \ccolpage{}s and thier footnotes (\!\pcol@output@switch!), \spanning{}
% and thier \fpage{}s (\!\pcol@startpage!), \fcolumn{}s
% (\!\pcol@flushcolumn!), single-column floats having $\cc_c(\vb^b)$ for
% \sync{}ation (\!\pcol@synccolumn!), and \spanning{} carried over at
% \Endparacol{} (\!\pcol@output@end!). 
% \end{description}
% 
% 
% 
% \subsubsection{Integer Registers}
% 
% \begin{description}
% \item[\Uidx{\!\outputpenalty!}]
% is \TeX's primitive register to have the page-break penalty with which
% \!\output! routine is invoked.  It is referred to by \!\pcol@output! to
% know whether it has special code less than $-10000$, and by
% \!\pcol@specialoutput! in detail for the dispatch according to the code.
% The register is also used for the communication from the latter, which lets
% it be $-10000$ for our own special \!\output! routines, to the former to
% determine \!\vsize! according to if the register has a value greater then
% $-10004$ or not.
% 
% \item[\Uidx{\!\interlinepenalty!}]
% is \TeX's primitive register to have the page-break penalty inserted
% between two lines.  The register is referred to by \!\pcol@restartcolumn!
% to insert the \!\penalty! in the register to resume a \colpage{}
% unless it is suspended after a sectioning command,
% i.e. $\CSIndex{if@nobreak}=\true$.
% 
% \item[\Uidx{\!\@ne!}]
% is a \!\chardef! register to have 1.  The register is referred to by the
% following macros mainly for incrementing another register.
% 
% \begin{quote}\raggedright
% \!\pcol@setpnoelt!, \!\pcol@nextpage!, \!\pcol@nextpelt!,
% \!\pcol@checkshipped!, \!\pcol@outputelt!, \!\pcol@specialoutput!,
% \!\pcol@output@switch!, \!\pcol@setcurrcol!, \!\pcol@flushcolumn!,
% \!\pcol@measurecolumn!, \!\pcol@synccolumn!, \!\pcol@makeflushedpage!,
% \!\pcol@flushfloats!, \!\pcol@output@end!, \!\paracol!,
% \!\pcol@synccounter!, \!\pcol@com@syncallcounters!, \!\pcol@stepcounter!,
% \!\pcol@com@switchcolumn!, \!\pcol@mctext!.
% \end{quote}
% 
% \item[\Uidx{\!\tw@!}]
% is a \!\chardef! register to have 2.  It is used in \!\pcol@setcurrcol! to
% let $\cc_c(\sw)=2$ when $\CSIndex{if@nobreak}=\true$ but
% $\CSIndex{if@afterindent}=\false$.
% 
% \item[\Uidx{\!\m@ne!}]
% is a \!\count! register to have $-1$.  It is used in \!\pcol@setpnoelt!,
% \!\pcol@nextpelt! and \!\pcol@getpelt! to decrement \!\@tempcnta! which
% initially has $p-\pbase$ for a page $p$.
% 
% \item[\Uidx{\!\@cclv!}]
% is a \!\chardef! register to have 255.  It is used in
% \!\pcol@setpnoelt! and \!\pcol@getpinfo! to examine if
% $\page(p)\in[0,255]$ for a page $p$.  See the description of \!\box!-type
% registers for its another usage of \!\box!\!\@cclv!.
% 
% \item[\Uidx{\!\@cclvi!}]
% is a \!\mathchardef! register to have 256.  It is used in
% \!\pcol@setordpage! to let $\pp(p)={\page(p)}+256$ and \!\pcol@getpinfo! to
% let $\page(p)=\pp(p)-256$ for a page $p$ such that $\page(p)\in[0,255]$.
% 
% \item[\Uidx{\!\@m!}]
% is a \!\mathchardef! register to have 1000.  It is used in
% \!\pcol@synccolumn! and \!\pcol@output@end! to let
% $\!\prevdepth!=1000\,|pt|$ on a \sync{}ation or the closing \env{paracol}
% environment with an empty main vertical list.
% 
% \item[\Uidx{\!\@M!}]
% is a \!\mathchardef! register to have 10000.  It is used in
% \!\pcol@output! to examine if $\!\outputpenalty!<-10000$ to mean a special
% \!\output! request, in \!\pcol@synccolumn! to put $\!\penalty!=-10000$
% to force page break for flushing columns, and in \!\pcol@synccolumn! to
% bias \!\pcol@textfloatsep! by 10000\,|pt| to indicate a colpage has an
% \mvlfloat{} and in \!\pcol@cflt! and \!\pcol@addflhd! to remove the bias.
% 
% \item[\Uidx{\!\@Miv!}]
% is a \!\mathchardef! register to have 10004.  It is used in \!\pcol@output!
% to examine if $\!\outputpenalty!=-10004$ for a dummy \!\output! request
% made by \LaTeX's float-related macros and our \!\pcol@invokeoutput! to
% ensure the real request is not eliminated when it is made at the very
% beginning of a page or a \colpage.
% 
% \item[\Uidx{\!\@topnum!}]
% is a \!\count! register to have the maximum number of top floats which the
% \ccolpage{} can accept further.  It is used in \!\pcol@setcurrcol!
% and \!\pcol@iigetcurrcol! to save\slash restore it into\slash from
% $\cc_c(\tn)$.  The macro \!\pcol@synccolumn! also lets $\!\@topnum!=0$ to
% inhibit top-float insertions in the \ccolpage{} any more after a
% \sync{}ation.
% 
% \item[\Uidx{\!\@botnum!}]
% is a \!\count! register to have the maximum number of bottom floats which
% the \ccolpage{} can accept further.  It is used in \!\pcol@setcurrcol!
% and \!\pcol@iigetcurrcol! to save\slash restore it into\slash from
% $\cc_c(\bn)$.
% 
% \item[\Uidx{\!\@colnum!}]
% is a \!\count! register to have the maximum total number of floats which
% the \ccolpage{} can accept further.  It is used in \!\pcol@setcurrcol!
% and \!\pcol@iigetcurrcol! to save\slash restore it into\slash from
% $\cc_c(\cn)$.
% 
% \item[\Uidx{\!\col@number!}]
% is a \!\count! register to have the number of columns.  It is let have 1
% by \!\paracol! and \!\pcol@mctext! regardless the real number of columns
% $\C$ in order to keep \!\maketitle! from putting the title by
% \!\twocolumn!.
% 
% \item[\Uidx{\!\c@page!}]
% is \LaTeX's counter \counter{page} being a \!\count! register to have the
% page number.  It is referred to by \!\pcol@setpnoelt!,
% \!\pcol@setordpage!, and \!\pcol@output@start! to let
% $\pp(p)$ represent $\page(p)$.  The macro \!\pcol@startpage! also does
% that for multi-column \fpage{}s incrementing the register.  Then
% $\page(p)$ is reloaded to the register from $\pp(p)$ by \!\pcol@getpelt!,
% \!\pcol@outputelt!, \!\pcol@sync! and \!\pcol@makeflushedpage!.  The other
% user is \!\pcol@remctrelt! which lets
% $|\cl@|{\cdot}\theta=\!\pcol@stepcounter!\Arg{\theta}$
% 
% \SpecialArrayIndex{\theta}{\cl@}
% 
% unless $\theta\neq\counter{page}$.
% 
% \item[$\cs{c@}{\cdot}\theta$]
% \Uidx{\SpecialArrayIndex{\theta}{\c@}}
% 
% is a \!\count! register being \LaTeX's counter $\theta$.  It is referred
% to by \!\pcol@savectrelt! to let $\val_c(\theta)=\Val(\theta)$ for saving
% it in $\Cc_c$, by \!\pcol@cmpctrelt! to examine if
% $\val_0(\theta)=\Val(\theta)$ to detect a modification outside
% \env{paracol} environment, and by \!\pcol@syncctrelt! to let
% $\val_c(\theta)=\Val(\theta)$ for all $c$ for \csync{}.  It is also
% referred to by \!\pcol@remctrelt! to examine if $\theta=\counter{page}$.
% The macros \!\pcol@setctrelt! and \!\pcol@stpldelt! restore the value of
% the counter from $\val_c(\theta)$, while \!\pcol@stpclelt! lets
% $\Val(\theta)=0$ for zero-clearing of descendent counters.
% 
% \item[\Uidx{\!\count@!}]
% is a \!\count! register for temporary use.  It is used in
% \!\pcol@getpinfo! to have $\pp(p)$ for a page $p$.
% 
% \item[\Uidx{\!\@tempcnta!}]
% is a \!\count! register for temporary use.  The usages of this register
% are as follows.
% 
% \begin{itemize}
% \item\begingroup\hbadness3700
% In \!\pcol@setpageno!, \!\pcol@setpnoelt!, \!\pcol@nextpage!,
% \!\pcol@nextpelt!,\break\!\pcol@getcurrpage! and \!\pcol@getpelt!, it
% has $p-q$ when we scan $\pp(q)$ for all $q\in[\pbase,\ptop]$ and the
% \ccolpage{} is at $p$.
% \par\endgroup
% 
% \item
% In \!\pcol@setordpage!, it has $\pp(p)=\page(p)$ or $\pp(p)=\page(p)+256$
% for a page $p$.
% 
% \item
% In \!\pcol@checkshipped!, it has $c$ when we scan $\S_c$ for all
% $c\In0\C$ to examine if all of them are not empty and thus we have pages
% to be shipped out.
% 
% \item
% In \!\pcol@outputelt!, it has $c$ when we scan $\s_c(q)$ for all
% $c\In0\C$ to build the shipping out image of a page $q$.
% 
% \item
% In \!\pcol@setcurrcol!, it has the code calculated from
% \CSIndex{if@nobreak} and |\if@after|\~|indent| to be saved in
% $\cc_c(\sw)$.
% 
% \SpecialIndex{\if@afterindent}
% 
% 
% \item
% In \!\pcol@flushcolumn!, it is used to throw $\page(\ptop)$ away when
% we get it by \!\pcol@getcurrpinfo! because we don't need it.
% 
% \item
% In \!\pcol@cmpctrelt!, it has $\Val(\theta)$ of a counter $\theta$ to be
% compared with $\val_0(\theta)$.
% 
% \item
% In \!\pcol@com@switchcolumn!, it has $c+1\bmod\C$ being the target of
% \cswitch{}.
% 
% \item
% In \!\pcol@mctext!, it temporarily has $d$ being the target of \cswitch{}
% during we let $\!\pcol@nextcol!=0$ to visit the first column for putting
% a \mctext{}.
% \end{itemize}
% \end{description}
% 
% 
% 
% \subsubsection{Dimension Registers}
% 
% \begin{description}
% \item[\Uidx{\!\vsize!}]
% is \TeX's primitive register to have the height of a page or a \colpage{}
% being built.  It is let be \!\@colroom! or \!\maxdimen! by
% \!\pcol@output!.
% 
% \item[\Uidx{\!\hsize!}]
% is \TeX's primitive register to have the width of a page or a \colpage{}
% being built.  It is let be \!\columnwidth! by \!\paracol!, while
% \!\pcol@mctext!  and \!\endparacol! let it be \!\textwidth!.
% 
% \item[\Uidx{\!\maxdepth!}]
% is \TeX's primitive register to have the maximum depth of the page being
% built.  It is referred to by \!\pcol@cflt! to let \!\boxmaxdepth! of
% \!\@outputbox!, in which top floats and the main vertical list are
% combined, be \!\maxdepth!.
% 
% \item[\Uidx{\!\boxmaxdepth!}]
% is \TeX's primitive register to have the maximum depth of \!\vbox!es.
% The macro \!\pcol@cflt! let it be \!\maxdepth! for \!\@outputbox! in which
% top floats and the main vertical list are combined, while the macro
% \!\pcol@makenormalcol! let it be \!\@maxdepth! for \!\@outputbox! in which
% \preenv{} is hold.
% 
% \item[\Uidx{\!\prevdepth!}]
% is \TeX's primitive register to have the depth of the box which just has
% been added to a vertical list, or to be given to \TeX's vertical list
% builder for the calculation of the vertical skip inserted below the last
% box.  The macro \!\pcol@invokeoutput! refers to it to save its value in
% \!\pcol@prevdepth! before putting a dummy \!\vbox! and making a \!\output!
% request, and then let it have \!\pcol@prevdepth! which is given by
% \!\output! routine for the column that we resume.  The macro \!\paracol!
% also refers to it to save it in \!\pcol@firstprevdepth! for the \preenv.
% 
% \item[\Uidx{\!\maxdimen!}]
% is a \!\dimen! register to have $16383.99999\,|pt|$ being the largest
% legal dimensional value.  The usages of this register are as follows.
% 
% \begin{itemize}
% \item
% In \!\pcol@output!, it is set into \!\vsize! when $\!\outputpenalty!=-10004$
% for the dummy \!\output! request so that no page break should occur
% between the dummy and real requests.
% 
% \item
% Our own \!\dimen! register \!\pcol@textfloatsep! has \!\maxdimen! if a
% \colpage{} does not have \sync{}ation points to let top floats are
% inserted in usual way.  Therefore, \!\pcol@floatplacement! and \!\paracol!
% let the register have \!\maxdimen! as the initial value.  Then the macros
% \!\pcol@makecol! and \!\pcol@combinefloats! examine if
% $\!\pcol@textfloatsep!=\!\maxdimen!$ to determine the operation type of
% top float insertion.  The macro \!\pcol@addflhd! also examines it for the
% measurement of the combined height of top and bottom floats, while
% \!\pcol@measurecolumn! gives it \!\maxdimen! as its third argument for
% bottom floats.
% 
% \item
% The \pctext{} $\pp^h(p)$ has $-\!\maxdimen!$ if the page is a \fpage{}.
% The macro \!\pcol@startpage! makes that when it creates such a page.
% 
% \item
% Our own \!\pcol@prevdepth! and that saved in $\cc_c(\pd)$ have
% \!\maxdimen! if the main vertical list is empty at a \sync{}ation.  The
% macro \!\pcol@measurecolumn! makes it when it finds a empty list.
% 
% \item
% The \cctext{} $\cc_c(\tr)$ may have \!\maxdimen! if the column $c$ has a
% \fcolumn{} in the \lpage{} of \env{paracol} environment and the floats in
% it can be put as top floats.  The macro \!\pcol@makefcolumn! makes this
% special assignment and \!\pcol@makeflushedpage! examines it.
% 
% \item
% At a \sync{}ation, we measure the maximum combined size of top floats and
% the main vertical list $\VT$, that of footnotes and bottom floats $\VB$,
% and that of four items $\VP$.  We also let $\DT$ and $\DP$ be the minimum
% depth of the \colpage{}s which gives $\VT$ and $\VP$ respectively.  For
% the measurement, the macro \!\pcol@sync! lets $\VT=\VB=\VP=-\!\maxdimen!$
% and $\DT=\DP=\!\maxdimen!$ as their initial values.  Then the macro
% \!\pcol@synccolumn! examines if $\DT=\!\maxdimen!$ to mean the
% \sync{}ation point is set just below the top floats of a column whose main
% vertical list is empty.  On the other hand, \!\pcol@makeflushedpage! and
% \!\pcol@output@end! examine if $\VP=-\!\maxdimen!$ to mean the last page is
% empty.
% \end{itemize}
% 
% \item[\Uidx{\!\textheight!}]
% is a \!\dimen! register for an API parameter of \LaTeX{} to have the
% height of a page.  The register is referred to by \!\pcol@output! to
% examine if a page is very short, by \!\pcol@getpinfo!, \!\pcol@startpage!,
% \!\pcol@flushfloats! and \!\pcol@output@end! to let \!\@colht! be it for a
% page without \spanning{} (so far), and by \!\pcol@outputelt!,
% \!\pcol@output@flush!, \!\pcol@output@clear! and \!\pcol@output@end! to
% build a page to be shipped out.
% 
% \item[\Uidx{\!\textwidth!}]
% is a \!\dimen! register for an API parameter of \LaTeX{} to have the width
% of a page.  The register is referred to by \!\pcol@outputelt!,
% \!\pcol@makeflushedpage! and \!\pcol@flushfloats! to build a \!\hbox! of
% \!\textwidth! wide to have all columns.  It also referred to by
% \!\paracol! for the calculation of \!\columnwidth!, and by \!\pcol@mctext!
% and \!\endparacol! to set it in \!\hsize! etc.
% 
% \item[\Uidx{\!\columnwidth!}]
% is a \!\dimen! register for an API parameter of \LaTeX{} to have the width
% of a column.  After the register is initialized by \!\paracol! according
% to the number of columns $\C$ and other parameters, it is referred to by
% \!\pcol@outputelt!, \!\pcol@makeflushedpage! and \!\pcol@flushfloats! to
% put each \colpage{} into a \!\hbox! of \!\columnwidth! wide for shipping a
% page out.  The register is also let have \!\textwidth! by \!\endparacol!
% for \postenv.
% 
% \item[\Uidx{\!\linewidth!}]
% is a \!\dimen! register for an API parameter of \LaTeX{} to have the width
% of a line possibly shorter than \!\columnwidth! in \env{list}-like
% environments.  It is let have \!\columnwidth! by \!\paracol! and
% \!\textwidth! by \!\endparacol! for outermost paragraphs inside\slash
% outside \env{paracol} environment respectively.
% 
% \item[\Uidx{\!\columnsep!}]
% is a \!\dimen! register for an API parameter of \LaTeX{} to have the width
% of inter-column spaces.  It is referred to by \!\paracol! to calculate
% \!\columnwidth!.
% 
% \item[\Uidx{\!\z@!}]
% is a \!\dimen! register to have 0\,|pt| and is used in the following macros.
% 
% \begin{quote}\raggedright
% \!\pcol@makecol!,
% \!\pcol@combinefloats!,
% \!\pcol@outputelt!,
% \!\pcol@output@start!,
% \!\pcol@floatplacement!,
% \!\pcol@sync!,
% \!\pcol@measurecolumn!,
% \!\pcol@synccolumn!,
% \!\pcol@output@end!.
% \end{quote}
% 
% It is also used to give the number 0 in the following macros.
% 
% \begin{quote}\raggedright
% \!\pcol@opcol!,
% \!\pcol@setpnoelt!,
% \!\pcol@setordpage!,
% \!\pcol@nextpelt!,
% \!\pcol@checkshipped!,
% \!\pcol@getpelt!,
% \!\pcol@getpinfo!,
% \!\pcol@outputelt!,
% \!\pcol@output@start!,
% \!\pcol@output@switch!,
% \!\pcol@setcurrcol!,
% \!\pcol@sync!,
% \!\pcol@synccolumn!,
% \!\pcol@makeflushedpage!,
% \!\pcol@flushfloats!,
% \!\pcol@freshpage!,
% \!\pcol@output@end!,
% \!\paracol!,
% \!\pcol@synccounter!,
% \!\pcol@com@syncallcounters!,
% \!\pcol@stepcounter!,
% \!\pcol@stpclelt!,
% \!\pcol@com@switchcolumn!,
% \!\pcol@switchcolumn!,
% \!\pcol@mctext!,
% \!\pcol@switchcol!,
% \!\endparacol!.
% \end{quote}
% 
% \item[\Uidx{\!\p@!}]
% is a \!\dimen! register to have 1\,|pt|.  It is used in
% \!\pcol@cflt!, \!\pcol@addflhd!, \!\pcol@synccolumn! and
% \!\pcol@output@end! as the shorthand of |pt|.
% 
% \item[\Uidx{\!\@maxdepth!}]
% is a \!\dimen! register to have \!\maxdepth! in case that it is
% temporarily modified.  It is used in \!\pcol@makenormalcol! to let
% \!\boxmaxdepth! have it.
% 
% \item[\Uidx{\!\@colht!}]
% is a \!\dimen! register to have the height of columns in a page possibly
% shrunk from \!\textheight! by \spanning.  The usages of the register
% are as folllows.
% 
% \begin{itemize}
% \item \begingroup\hbadness1750
% In macros \!\pcol@startpage!, \!\pcol@output@start!, \!\pcol@flushfloats!
% and\break\!\pcol@output@end!, it is initialized to \!\textheight!.  In first
% two, the value of the register is reduced to reflect \spanning{} and then
% set into $\pp^h(p)$, if \spanning{} exists.
% \par\endgroup
% 
% \item \begingroup\tolerance1500 \hbadness1500
% In macros \!\pcol@getpelt!, \!\pcol@sync!, \!\pcol@flushcolumn!,
% \!\pcol@measure~column!  and \!\pcol@makeflushedpage!, it is let have
% $\pp^h(p)$.  In addition \!\pcol@sync! examines if $\!\@colht!<\VT+\VB$, and
% \!\pcol@makefcolumn! uses it to initialize the room of a \fpage.
% \par\endgroup
% 
% \item
% In macros \!\pcol@startcolumn!, \!\pcol@flushcolumn! and
% \!\pcol@freshpage!, it is used to let \!\@colroom! have it.
% 
% \item
% In macros \!\pcol@output@flush! and \!\pcol@output@clear!, it is given to
% \!\pcol@makeflushedpage! as its argument.  The macro
% \!\pcol@makeflushedpage! lets \!\@colht! be the argument if it is less
% than \!\@colht! and thus is given by \!\pcol@output@end!.
% \end{itemize}
% 
% \item[\Uidx{\!\@colroom!}]
% is a \!\dimen! register to have the height of a column possibly shrunk
% from \!\@colht! by top and bottom floats.  The register is initialized to
% have \!\@colht! by \!\pcol@startcolumn!, \!\pcol@output@start!,
% \!\pcol@flushcolumn! and \!\pcol@freshpage!, the last three of which also
% save it into $\cc_c(\vb^r)$.  This save operation is also done by
% \!\pcol@output@switch!, while restoring from it done by
% \!\pcol@restartcolumn!.  The macro \!\pcol@output! also refers to this
% register to let \!\vsize! have it.   The macro \!\pcol@output@end! lets
% the register have \!\textheight! for the \postenv{} because the
% \colpage{}s above it simply precedes the stuff in the main vertical list.
% The other users \!\pcol@makefcolumn! and \!\pcol@makefcolelt! use this
% register to accumulate the total size of floats to be put in a \fcolumn{}
% temporarily.
% 
% \item[\Uidx{\!\@toproom!}]
% is a \!\dimen! register to have the room for top floats.  The register is
% saved in $\cc_c(\tr)$ by \!\pcol@setcurrcol! and restored from it by
% \!\pcol@iigetcurrcol!.  The macro \!\pcol@makefcolumn! uses this register
% as a flag to indicate that $\cc_c(\tl)$ of the column $c$ having
% $\cc_c(\tr)=\infty$ contains floats to be put in its last \fcolumn{}
% possibly as top floats so that it is examined by \!\pcol@makeflushedpage!.
% 
% \item[\Uidx{\!\@botroom!}]
% is a \!\dimen! register to have the room for bottom floats.  The register
% is saved in $\cc_c(\br)$ by \!\pcol@setcurrcol! and restored from it by
% \!\pcol@iigetcurrcol!.
% 
% \item[\Uidx{\!\@fpmin!}]
% is a \!\dimen! register to have $\!\floatpagefraction!\times\!\@colht!$
% being the minimum total size of floats for which an ordinary (not flushed)
% \fcolumn{} can be build.  It is referred to by \!\pcol@makefcolumn! as the
% threshhold below which floats in the last \fcolumn{} can be put as top
% floats.
% 
% \item[\Uidx{\!\@mparbottom!}]
% is a \!\dimen! register to have the bottom position of the last
% \!\marginpar! stuff.  It is initialize to be 0 by \!\pcol@floatplacement!,
% saved in $\cc_c(\mb)$ by \!\pcol@setcurrcol!, and restored from it by
% \!\pcol@iigetcurrcol!.
% 
% \item[\Uidx{\!\@textfloatsheight!}]
% is a \!\dimen! register to have the combined height of mid floats and
% their separators.  It is initialize to be 0 by \!\pcol@floatplacement!,
% saved in $\cc_c(\fh)$ by \!\pcol@setcurrcol!, and restored from it by
% \!\pcol@iigetcurrcol!.
% 
% \item[\Uidx{\!\dimen@!}]
% is a \!\dimen! register for temporary use.  It is used in 
% \!\pcol@addflhd! and \!\pcol@hdflelt! to measure the height of top and
% bottom floats, and in \!\pcol@measurecolumn! for them and $\VT$, $\VB$ and
% $\VP$.  The other user \!\pcol@synccolumn! lets it have
% $\!\textfloatsep!-\!\floatsep!$ or 0 for the adjustment of the position
% of $\cc_c(\vb^b)$ in the last top float and \!\pcol@textfloatsep!
% following it for a \sync{}ation whose point determined by a column having
% empty main vertical list.
% 
% \item[\Uidx{\!\dimen@ii!}]
% is a \!\dimen! register for temporary use.  It is used in 
% \!\pcol@measurecolumn! for $\VT$, $\VP$ and $\DP$.
% 
% \item[\Uidx{\!\@tempdima!}]
% is a \!\dimen! register for temporary use.  The usages of this register
% are as follows.
% 
% \begin{itemize}
% \item
% In \!\pcol@combinefloats!, it has the natural component of
% \!\textfloatsep! to be used for the shrink of the vertical skip following
% it, when we put them below the bottom floats in the last page of
% \env{paracol} environment.
% 
% \item
% In \!\pcol@startpage!, it is used to throw $\pp^h(p)$ away when
% we get it by \!\pcol@getcurrpinfo! because we don't need it.
% 
% \item
% In \!\pcol@outputelt!, it has $\pp^h(p)$ to examine if $p$ is a \fpage.
% 
% \item
% In \!\pcol@makefcolumn! and \!\pcol@makefcolelt!, it has the room for
% floats to be put in a \fcolumn{} in the \lpage{}.
% 
% \item
% In \!\pcol@sync!, \!\pcol@measurecolumn! and \!\pcol@synccolumn!, it has
% $\VT$ being the maximum combined height of top floats and the main
% vertical list.
% \end{itemize}
% 
% \item[\Uidx{\!\@tempdimb!}]
% is a \!\dimen! register for temporary use.  It has $\VB$ in \!\pcol@sync!
% and \!\pcol@measurecolumn!, has the size of a float in
% \!\pcol@makefcolelt!, and has $\cc_c(\tf)=\!\pcol@textfloatsep!$ in
% \!\pcol@synccolumn!.
% 
% \item[\Uidx{\!\@tempdimc!}]
% is a \!\dimen! register for temporary use.  It has $\DT$ in
% \!\pcol@sync!, \!\pcol@measurecolumn! and \!\pcol@synccolumn!, and has
% \!\floatsep! or \!\@fpsep! in \!\pcol@makefcolumn! and
% \!\pcol@makefcolelt!.
% 
% \item[\Uidx{\!\@pageht!}]
% is a \!\dimen! register to be used in \LaTeX's \!\@specialoutput! to have
% the height of \!\@holdpg!.  However, we use it as a scratchpad to save
% $\pp^h(\ptop)$ in \!\pcol@makeflushedpage!.
% 
% \item[\Uidx{\!\@pagedp!}]
% is a \!\dimen! register to be used in \LaTeX's \!\@specialoutput! to have
% the depth of \!\@holdpg!.  However, we use it as a scratchpad to have
% $\DP$ in \!\pcol@sync!, \!\pcol@measurecolumn! and \!\pcol@output@end!.
% \end{description}
% 
% 
% 
% \subsubsection{Skip Registers}
% 
% \begin{description}
% \item[\Uidx{\!\baselineskip!}]
% is \TeX's primitive register to have the vertical skip to separate
% adjacent baselines.  It is referred to by \!\pcol@output! and
% \!\pcol@output@start! to examine if \!\@colroom! is unexpectedly small.
% 
% \item[\Uidx{\!\topskip!}]
% is \TeX's primitive register to have the vertical skip from the top edge
% of a page to the baseline of its first vertical item.  It is let be 0 by
% \!\pcol@output@start! if we have \preenv{} and is saved in $\pp^t(0)$,
% while \!\pcol@startpage! lets it be \!\pcol@topskip!, into which
% \!\paracol! saves the value outside \env{paracol} environment, saving the
% value in $\pp^t(p)$.  Then the register is restored from $\pp^t(p)$ by
% \!\pcol@getpelt! and \!\pcol@sync!, while \!\pcol@synccolumn! refers to
% the value restored by the latter to adjust a \sync{}ation point.  The
% macro \!\pcol@output@end! temporarily lets the register has 0 if we have
% non-empty columns in the last page, while \!\endparacol! restores it from
% \!\pcol@topskip! for the pages outside \env{paracol} environmnet.
% 
% \item[\Uidx{\!\floatsep!}]
% is a \!\skip! register to have the vertical skip between adjacent floats.
% It is referred to by \!\pcol@cflt! to cancel the skip following the last
% float, by \!\pcol@makefcolumn! and \!\pcol@makefcolelt! to examine the
% capacity of a \fcolumn{} in the \lpage, and by \!\pcol@addflhd! and
% \!\pcol@hdflelt!  to measure the total height of top and bottom floats.
% 
% \item[\Uidx{\!\textfloatsep!}]
% is a \!\skip! register to have the vertical skip between the main vertical
% list and top\slash bottom floats.  It is referred to by
% \!\pcol@combinefloats! to insert a skip below the bottom floats in the
% \lpage{} of \env{paracol} environment, by \!\pcol@measurecolumn! to take
% this skip into account in the calculation of $\VP$, by \!\pcol@addflhd! to
% measure the vertical space for top and bottom floats, and by
% \!\pcol@synccolumn! to calculate the \sync{}ation point for columns with
% top floats.
% 
% \item[\Uidx{\!\dblfloatsep!}]
% is a \!\skip! register to have the vertical skip between adjacent
% multi-column floats, and is used in \!\pcol@startpage! to cancel the skip
% below the last float.
% 
% \item[\Uidx{\!\dbltextfloatsep!}]
% is a \!\skip! register to have the vertical skip between the last
% multi-column float and the top of columns, and is used in
% \!\pcol@startpage! to put the skip.
% 
% \item[\Uidx{\!\@fptop!}]
% is a \!\skip! register to have the vertical skip inserted at the top of
% a \fcolumn, and is used in \!\pcol@makefcolumn! and
% \!\pcol@makeflushedpage!.
% 
% \item[\Uidx{\!\@fpsep!}]
% is a \!\skip! register to have the vertical skip between adjacent floats
% in a \fcolumn, and is used in \!\pcol@makefcolumn! and
% \!\pcol@makeflushedpage!.
% 
% \item[\Uidx{\!\@fpbot!}]
% is a \!\skip! register to have the vertical skip inserted at the bottom of
% a \fcolumn, and is used in \!\pcol@makefcolumn! and
% \!\pcol@makeflushedpage!.
% 
% \item[\Uidx{\!\@tempskipa!}]
% is a \!\skip! register for temporary use.  It is used to throw $\pp^t(p)$
% away in \!\pcol@startpage!, \!\pcol@outputelt!, \!\pcol@flushcolumn!
% and \!\pcol@makeflushedpage! because we don't need it.  The macro
% \!\pcol@output@start! uses it to determine \!\topskip! for the \spage.
% \end{description}
% 
% 
% 
% \subsubsection{Box Registers}
% 
% \begin{description}
% \item[\Uidx{\!\@cclv!}] 
% is a \!\box! register but \TeX{} defines that it has the main vertical
% list when \!\output! routine is invoked.  It is referred to by
% \!\pcol@specialoutput! to discard the dummy \!\vbox! inserted by
% \!\pcol@invokeoutput!, and is let have the main vertical list of a column
% to be passed to \!\@makecol! by \!\pcol@flushcolumn! and
% \!\pcol@makeflushedpage!.
% 
% \item[\Uidx{\!\voidb@x!}]
% is a \!\box! register to be void always.  It is referred to
% by \!\pcol@outputelt! to initialize \!\@outputbox! and to examine if
% $\S_c$ is empty, by \!\pcol@output@switch! and \!\pcol@setcurrcolnf! to
% let $\cc_c(\ft^b)$ be void if a column does not have footnotes, and by
% \!\pcol@getcurrfoot! to let \!\footins! be void if so.
% 
% \item[\Uidx{\!\@holdpg!}]
% is a \!\box! register to have the main vertical list when \!\output! is
% invoked with a special \!\penalty! code.  It is let have that by
% \!\pcol@specialoutput!, and is referred to by \!\pcol@makenormalcol! for
% \preenv{} and by \!\pcol@output@switch! for the column from which we are
% leaving.
% 
% \item[\Uidx{\!\@outputbox!}]
% is a \!\box! register to have a partial or the complete shipping-out image
% of a column or a page.  The usages of the register are as follows.
% 
% \begin{itemize}
% \item
% In \!\pcol@combinefloats!, it has a \colpage{} to which top and bottom
% floats are combined.
% 
% \item
% In \!\pcol@cflt!, it has a \colpage{} to which top floats are combined.
% 
% \item
% In \!\pcol@opcol!, it has the complete \colpage{} built by \!\@makecol!.
% 
% \item
% In \!\pcol@startpage!, it has the complete \fpage{} built by \!\@tryfcolumn!.
% 
% \item
% In \!\pcol@outputelt!, it has the complete page to be shipped out by
% \!\@outputpage!.
% 
% \item \begingroup\tolerance1700\hbadness1700
% In \!\pcol@output@start!, it has the \preenv{} built by
% \!\pcol@makenormalcol!.
% \par\endgroup
% 
% \item
% In \!\pcol@flushcolumn!, it has a flushed \colpage{} built by \!\@makecol!
% or a \fcolumn{} built by \!\@makefcolumn!.
% 
% \item
% In \!\pcol@output@flush! and \!\pcol@output@clear!, it has a flushed page
% built by \!\pcol@makeflushedpage! in which it has each of flushed
% \colpage{} built by \!\@makecol!.
% 
% \item
% In \!\pcol@flushfloats!, it has the complete page for flushed \fcolumn{}s
% each of which \!\@makefcolumn! builds also in it.
% 
% \item
% In \!\pcol@output@end!, it has the shipping-out image of the \lpage{} of
% \env{paracol} environment built by \!\pcol@makeflushedpage!.
% \end{itemize}
% 
% \item[\Uidx{\!\@tempboxa!}]
% is a \!\box! register for temporary use.  The usages of the register are
% as follows.
% 
% \begin{itemize}
% \item \begingroup\tolerance2100\hbadness2100
% In \!\pcol@cflt! and \!\pcol@startpage!, it has top single-\slash
% multi-column floats combined by the application of
% \!\@comflelt!\slash\!\@comdblflelt! to \!\@toplist!\slash\!\@dbltoplist!
% respectively.
% \par\endgroup
% 
% \item
% In \!\pcol@specialoutput!, it is used to discard the dummy \!\vbox! put by
% \!\pcol@invokeoutput!.
% 
% \item
% In \!\pcol@measurecolumn!, it is used to examine if the main vertical list
% is empty.
% % \end{itemize}
% \end{description}
% 
% 
% 
% \subsubsection{Token Registers}
% 
% \begin{description}
% \item[\Uidx{\!\output!}]
% is \TeX's primitive to have \!\output! routine.  It is let have
% \!\pcol@output! as its sole token by \!\paracol!.
% 
% \item[\Uidx{\!\everypar!}]
% is \TeX's primitive to have tokens inserted at the beginning of each
% paragarph.  In \!\pcol@mctext! and \!\pcol@com@endcolumn!, it is
% \!\global!ized to keep its contents after the end of a group.  In
% \!\pcol@output@switch!, its contents are broadcasted to $\cc_c(\ep)$ for
% all $c\In0\C$ if columns are \sync{}ed with a \mctext.  Then these values
% or that simply given in a column are saved into $\cc_c(\ep)$ by
% \!\pcol@setcurrcol!, and then restored from it by \!\pcol@iigetcurrcol!.
% 
% \item[\Uidx{\!\@temptokena!}]
% is a \!\toks! register for temporary use.  It is used in
% \!\pcol@output@switch! to broadcast \!\everypar! to $\cc_c(\ep)$ for all
% $c\In0\C$.
% 
% \end{description}
% 
% 
% 
% \subsubsection{Switches}
% 
% \begin{description}
% \item[\Uidx{\CSIndex{if@twocolumn}}]
% is a switch to be $\true$ iff multi-column pages are being typeset.  It is
% turned $\true$ by \!\paracol!, and then turned $\false$ by \!\endparacol!.
% 
% \item[\Uidx{\CSIndex{if@firstcolumn}}]
% is a switch to be $\true$ iff the first column is being typeset.  It is
% turned $\true$ by \!\paracol!, and so by \!\pcol@switchcol! iff it is to
% switch to the column 0.
% 
% \item[\Uidx{\CSIndex{if@nobreak}}]
% is a switch to be $\true$ iff the last paragraph is for a sectioning
% command.  The switch is saved into $\cc_c(\sw)$ together with
% \CSIndex{if@afterindent} by \!\pcol@setcurrcol!, and then restored from
% it by \!\pcol@iigetcurrcol!.  The macro \!\pcol@output@switch! refers to
% it to broadcast the value set by a \mctext{} to $\cc_c(\sw)$ for all
% $c\In0\C$.  The \!\pcol@restartcolumn! inserts $\!\penalty!=10000$ by
% \!\nobreak! if the switch is $\true$.
% 
% \item[\Uidx{\CSIndex{if@afterindent}}]
% is a switch to be $\true$ iff a sectioning commmand tells that the fisrt
% paragraph following it is to be indented.  The switch is saved into
% $\cc_c(\sw)$ together with \CSIndex{if@nobreak} by \!\pcol@setcurrcol!,
% and then restored from it by \!\pcol@iigetcurrcol!.
% 
% \item[\Uidx{\CSIndex{if@fcolmade}}]\begingroup\hfuzz0.45pt
% is a switch to be $\true$ iff a \fpage{} is built by \!\@tryfcolumn! or
% \!\@makefcolumn!.  The value is set by \!\@tryfcolumn! for $\cc_c(\dl)$ is
% referred to by \!\pcol@output!, \!\pcol@startcolumn!, \!\pcol@freshpage!
% and \!\pcol@output@end!, while that for \!\@dbldeferlist! is referred to
% by \!\pcol@startpage!.  The value set by \!\@makefcolumn! for
% $\cc_c(\dl)$ is referred to by \!\pcol@flushcolumn!, while that for
% \!\@dbldeferlist! is referred to by \!\pcol@output@clear!.  The macro
% \!\pcol@makeflushedpage! and \!\pcol@flushfloats! also turns the switch
% $\true$ iff \fcolumn{}s are to be built so that the latter itself
% and \!\pcol@output@end! know that.
% \par\endgroup
% 
% \item[\Uidx{\CSIndex{if@tempswa}}]
% is a switch for temporary use.  The usages of the switch are as follows.
% 
% \begin{itemize}
% \item
% In \!\pcol@checkshipped!, it is turned $\true$ iff $\S_c$ for all
% $c\In0\C$ have \colpage{}s to be shipped out, and then it is examined by 
% \!\pcol@opcol!.
% 
% \item
% In \!\pcol@nextpage! and \!\pcol@nextpelt!, it is $\true$ until
% \!\pcol@nextpelt! finds the first $q$ such that $q>p$ and
% $\pp^h(q)\geq0$ to mean $q$ is not for a \fpage{}, so that we let $p=q$
% to skip \fpage{}s following to the old $p$ if any.
% 
% \item
% In \!\pcol@outputpage! and \!\pcol@outputelt!, it is $\true$ until
% \!\pcol@outputelt! finds the first $q$ such that $q\geq\pbase$ and
% $\pp^h(q)\geq0$ to mean $q$ is not for a \fpage{}, and the arguemnt of
% \!\pcol@outputpage! is 0 to mean that it is not for page flushing, so that
% we ship out $q$ and all \fpage{}s following it if any.
% 
% \item
% In \!\pcol@output@switch!, at first it holds \CSIndex{if@nobreak} of the
% \mctext{} if columns are \sync{}ed with it to broadcast
% \CSIndex{if@nobreak} to all $\cc_c(\sw)$.  Then it is turned $\true$ iff
% $\CSIndex{ifpcol@sync}=\true$ for \sync{}ation or $\CSIndex{ifpcol@clear}$
% for flushing, so as to invoke \!\pcol@sync!.
% 
% \item
% In \!\pcol@sync!, it is turned $\true$ iff the page with the \sync{}ation
% point being set is not to be flushed, so that it is examined by
% \!\pcol@synccolumn!.
% 
% \item
% In \!\pcol@makefcolumn!, it is turned $\true$ iff the macro is acting on a
% column in the \lpage{}, $\cc_c(\dl)$ is emptied by the macro itself, and
% the total size of the floats to be put in the \fcolumn{} being built by
% the macro is less than \!\@fpmim!, to mean it is possible that the floats
% is put in the \fcolumn{} as top floats.
% 
% \item
% In \!\pcol@measurecolumn! and \!\pcol@addflhd!, it is set to be $\false$
% iff both top floats and the main vertical list are empty, so that
% \!\pcol@measureupdate! examines it for the update of $\VT$ and $\DT$.
% Then it is kept $\false$ iff both of footnotes and bottom floats are
% empty, so that \!\pcol@measureupdate! examines it for the update of $\VP$
% and $\DP$.
% 
% \item
% In \!\pcol@flushfloats!, it is turned $\true$ iff one or more columns have
% non-empty $\cc_c(\dl)$ after shipping a page for \fcolumn{}s out, so that
% \CSIndex{if@fcolmade} is let have its value after scanning all columns.
% 
% \item
% In \!\pcol@makeflushedpage!, it is turned $\true$ iff $\cc_c(\tr)=\infty$
% and $\VP=\pp^h(\ptop)$ to mean the floats in $\cc_c(\tl)$ should be put in
% a \fcolumn{} in the \lpage{} as usual.
% 
% \item
% In \!\pcol@output@end!, at first it is turned $\true$ iff the last page is
% not empty when we have \fcolumn{}s to be built, so that the last page is
% shipped out prior to the pages of \fcolumn{}s.  Then it is turned $\true$
% iff we built \fcolumn{}s, or the main vertical list in the \lpage{} is
% empty and the page is not the \spage, so that we create a new page for the
% \postenv.
% 
% \item
% In $\!\pcol@cmpctrelt!\arg{\theta}$, it is turned $\true$ iff $\theta$ is
% not in $\Cc_0$ or $\Val(\theta)\neq\val_0(\theta)$, so that $\theta$ is
% added to \!\@gtempa! being the list of \lcounter{}s to be synchronized.
% 
% \item
% In $\!\pcol@ac@caption@def!\arg{s}\arg{t}$, \CSIndex{@tempswatrue} or
% \CSIndex{@tempswafalse} is given as its first argument $s$ by
% $\!\pcol@ac@caption@enable!$ or $\!\pcol@ac@caption@disable!$ respectively,
% so that $|\if@ac@caption@if@|{\cdot}t$ is made \!\let!-equal to $s$ and
% \!\pcol@ac@caption! examines it for enabling\slash disabling
% \!\addcontentsline! respectively.  The macros \!\pcol@ac@caption@if@lof!
% and \!\pcol@ac@caption@if@lof! are initialized to be \!\let!-equal to
% \!\@tempswatrue! as the default.
% \end{itemize}
% \end{description}
% 
% 
% 
% \subsection{Macros}
% \label{sec:imp-tex-macro}
% 
% \subsubsection{Procedural Macros}
% 
% \begin{description}
% \item[\Uidx{\CSIndex{par}}]
% is \TeX's primitive to end\slash start paragraphs, but may be modified by
% \LaTeX{} to have some special functionality occasionally.  The macro
% \!\pcol@output! makes it \!\let!-equal to \!\@@par! in which the \TeX's
% orinigal definition is kept, while \!\paracol! and \!\pcol@par! use it as
% is.
% 
% \item[\Uidx{\!\space!}]
% is an API macro to have a space token.  It is used in \!\pcol@output! for
% a warning message.
% 
% \item[\Uidx{\!\thepage!}]
% is an API macro to have the representation of the counter \counter{page}.
% It is used in \!\pcol@output! for a warning message.
% 
% \item[\Uidx{$\cs{the}{\cdot}\theta$}]
% \SpecialArrayIndex{\theta}{\the}
% 
% is an API macro to have the representation of the counter $\theta$.  The
% macro is kept in $|\pcol@thectr@|{\cdot}\theta$
% 
% \SpecialArrayIndex{\theta}{\pcol@thectr@}
% 
% by \!\pcol@thectrelt! which also makes the macro \!\let!-equal to
% $|\pcol@thectr@|{\cdot}\theta{\cdot}0$
% 
% \SpecialArrayIndex{\theta{\cdot}c}{\pcol@thectr@}
% 
% if the \lrep{} of $\theta$ in the column 0 is defined by
% \!\definethecounter!.  The macro \!\pcol@setctrelt! also makes this
% overriding for the column $c$ to which the macro belongs if the \lrep{}
% for $c$ being $|\pcol@thectr@|{\cdot}\theta{\cdot}c$
% 
% \SpecialArrayIndex{\theta{\cdot}c}{\pcol@thectr@}
% 
% is defined, while it makes $|\the|{\cdot}\theta$
% 
% \SpecialArrayIndex{\theta}{\the}
% 
% \!\let!-equal to $|\pcol@thectr@|{\cdot}\theta$
% 
% \SpecialArrayIndex{\theta}{\pcol@thectr@}
% 
% otherwise to give it its original definition.
% 
% \item[\Uidx{$\!\stepcounter!\<\theta\>$}]
% is an API macro to increment the counter $\theta$ and zero-clear its
% descendant counters.  It is used in \!\pcol@startpage! for the counter
% \counter{page}.
% 
% \item[\Uidx{\!\nobreak!}]
% is an API macro to insert $\!\penalty!=10000$ to inhibit line or page
% breaks.  It is used in \!\pcol@restartcolumn! to meet the page-break
% inhibition request made by $\CSIndex{if@nobreak}=\true$.
% 
% \item[\Uidx{$\!\addpenalty!\arg{pen}$}]
% is an API macro to insert a page break $\!\penalty!=\arg{pen}$ if
% $\CSIndex{if@nobreak}=\false$.  The \!\penalty! is inserted removing the
% last vertical skip which is reinserted after the \!\penalty!.  The macro
% is used in \!\pcol@restartcolumn! to insert \!\interlinepenalty! if
% $\CSIndex{if@nobreak}=\false$.
% 
% \item[\Uidx{$\!\addcontentsline!\arg{file}\arg{sec}\arg{entry}$}]
% is an API macro to put \!\addtocontents! for the arguments to |.aux| file.
% The orignial definition of the macro is kept in
% \!\pcol@addcontentsline! so that \!\pcol@ac@disable@toc! and
% \!\pcol@ac@caption! make the macro regain its original definition after
% disabling it by making it \!\let!-equal to \!\pcol@gobblethree!.
% 
% \item[\Uidx{\!\footnoterule!}]
% is an API macro to draw a horizontal line above footnotes, or to insert
% whatever it has before them.  The macro is used in \!\pcol@makenormalcol!
% to combine the main vertical list and footnotes if provided to build the
% \preenv{} in \!\@outputbox!.
% 
% \item[\Uidx{\!\dblfigrule!}]
% is an API macro to draw a horizontal line between the last multi-column
% floats and the main vertical list, or to insert whatever it has between
% them.  The macro is used in \!\pcol@startpage! to build \spanning{} in
% the page $p$ in $\pp^b(p)$.
% 
% \item[\Uidx{\!\topfigrule!}]
% is an API macro to draw a horizontal line between the last single-column
% top float and the main vertical list, or to insert whatever it has between
% them.  The macro is used in \!\pcol@cflt! and \!\pcol@synccolumn! to
% insert it below the last (real) top float.  It is also made \!\let!-equal
% to \!\relax! temporarily by \!\pcol@makeflushedpage! when it put floats in
% a \fcolumn{} as top floats.  Note that the macro and its bottom
% counterpart \!\botfigrule! should produce a vertical list whose total
% height and depth is 0, because \LaTeX's float mechanism and thus our
% macros believe so.
% 
% \item[\Uidx{\!\normalcolor!}]
% is an API macro to have color specification stuff for normal coloring.
% The macro is used in \!\pcol@makenormalcol! to specify the color of
% footnotes if provided to include them as a part of \preenv{} in
% \!\@outputbox!.
% 
% \item[\Uidx{$\!\PackageError!\arg{pkg}\arg{msg}\arg{hlp}$}]
% is a developer's API macro to stop the exectution showing the error message
% $\arg{msg}$ with the package identification $\arg{pkg}$ and the help
% mssage $\arg{hlp}$.  The macro is used in \!\pcol@ovf! in case of
% \!\@freelist! shortage, in \!\paracol! for illegal nesting, in
% \!\pcol@switchenv! for illegal \cswitch{} commands\slash
% environments in a \csenv, in \!\pcol@switchcolumn! for invalid target
% column, and in \!\addcontentsonly! for unknown contents type.
% 
% \item[\Uidx{\!\@@par!}]
% is an internal macro to keep \TeX's original primitive \CSIndex{par} in it.
% The macro is used in \!\pcol@output! to let \CSIndex{par} act with its
% original definition.
% 
% \item[\Uidx{\!\@height!}]
% is an internal macro having the keyword |height|.  It is used in
% \!\pcol@output@start! to draw an invisible \!\hrule!.
% 
% \item[\Uidx{\!\@width!}]
% is an internal macro having the keyword |width|.  It is used in
% \!\pcol@output@start! to draw an invisible \!\hrule!.
% 
% \item[\Uidx{\!\@plus!}]
% is an internal macro having the keyword |plus|.  It is used in
% \!\pcol@makecol! to \!\def!ine \!\@textbottom! with the body of a vertical
% skip with infinite stretch and shrink, and in \!\pcol@synccolumn! to put a
% vertical skip with infinite stretch to push up the main vertical list
% above a \sync{}ation point.
% 
% \item[\Uidx{\!\@minus!}]
% is an internal macro having the keyword |minus|.  It is used in
% \!\pcol@makecol! to \!\def!ine \!\@textbottom! with the body of a vertical
% skip with infinite stretch and shrink, and in \!\pcol@combinefloats! to
% put a vertical skip with a shrink of \!\textfloatsep! so that the skip of
% \!\textfloatsep! above it can be canceled if necessary.
% 
% \item[\Uidx{\!\hb@xt@!}]
% is an internal macro having the sequence ``\!\hbox!| to|''.  It is used in 
% \!\pcol@outputelt!, \!\pcol@makeflushedpage! and \!\pcol@flushfloats! to
% put each \colpage{} in a \!\hbox! of \!\columnwidth! wide and to enclose
% all of them in a \!\hbox! of \!\textwidth! wide.
% 
% \item[\Uidx{$\!\@namedef!\arg{cs}\arg{body}$}]
% is an internal macro to do $\!\def!|\|\arg{cs}\Arg{body}$.  It is used in
% the following macros.
% 
% \begin{itemize}
% \item
% \!\paracol! for \!\column*! and \!\pcol@com@column*!.
% 
% \item
% $\!\pcol@remctrelt!\<\theta\>$ for $|\cl@|{\cdot}\theta$.
% 
% \SpecialArrayIndex{\theta}{\cl@}
% 
% \item
% $\!\definethecounter!\<\theta\>\<c\>\arg{rep}$ for
% $|\pcol@thectr@|{\cdot}\theta{\cdot}c$,
% 
% \SpecialArrayIndex{\theta{\cdot}c}{\pcol@thectr@}
% 
% \item
% $\!\pcol@loadctrelt!\<\theta\>\<\val_c(\theta)\>$ for
% $|\pcol@ctr@|{\cdot}\theta$.
% 
% \SpecialArrayIndex{\theta}{\pcol@ctr@}
% \end{itemize}
% 
% \item[\Uidx{$\!\@nameuse!\arg{cs}$}]
% is an internal macro to do $|\|\arg{cs}$.  It is used in the following
% macros.
% 
% \begin{itemize}
% \item
% \!\column*! for \!\pcol@com@column*!.
% 
% \item
% $\!\pcol@storectrelt!\<\theta\>$ for $|\pcol@ctr@|{\cdot}\theta$.
% 
% \SpecialArrayIndex{\theta}{\pcol@ctr@}
% 
% \item
% $\!\pcol@cmpctrelt!\<\theta\>$ for $|\c@|{\cdot}\theta$
% 
% \SpecialArrayIndex{\theta}{\c@}
% 
% and $|\pcol@ctr@|{\cdot}\theta$.
% 
% \SpecialArrayIndex{\theta}{\pcol@ctr@}
% 
% \item
% \!\pcol@synccounter! for $|\pcol@counters|{\cdot}c$ for the column $c$.
% 
% \SpecialArrayIndex{c}{\pcol@counters}
% 
% \item
% $\!\pcol@syncctrelt!\<\theta\>$ for $|\c@|{\cdot}\theta$.
% 
% \SpecialArrayIndex{\theta}{\c@}
% 
% \item
% $\!\pcol@stepcounter!\<\theta\>$ for $|\pcol@counters|{\cdot}c$ for the
% column $c$,
% 
% \SpecialArrayIndex{c}{\pcol@counters}
% 
% and for $|\cl@|{\cdot}\theta$.
% 
% \SpecialArrayIndex{\theta}{\cl@}
% 
% \item
% $\!\pcol@aconlyelt!\<t\>\<c\>$ for $|\pcol@ac@def@|{\cdot}t$.
% 
% \SpecialIndex{\pcol@ac@def@lof}\SpecialIndex{\pcol@ac@def@lot}
% 
% \item
% $\!\pcol@ac@def@lof!\arg{eord}$ and $\!\pcol@ac@def@lot!\arg{eord}$ for
% $|\pcol@ac@caption@|{\cdot}\~\arg{eord}$.
% 
% \SpecialIndex{\pcol@ac@caption@enable}
% \SpecialIndex{\pcol@ac@caption@disable}
% 
% \item
% $\!\pcol@ac@caption!\arg{type}|[|\arg{lcap}|]|\arg{cap}$ for
% $|\pcol@ac@caption@if@|{\cdot}t$
% 
% \SpecialIndex{\pcol@ac@caption@if@lof}
% \SpecialIndex{\pcol@ac@caption@if@lot}
% 
% and for $|\ext@|{\cdot}\~\arg{type}$.
% 
% \SpecialIndex{\ext@figure}\SpecialIndex{\ext@table}
% \end{itemize}
% 
% \item[\Uidx{$\!\@ifundefined!\arg{cs}\arg{then}\arg{else}$}]
% is an internal macro to do $\arg{then}$ or $\arg{else}$ if $\arg{cs}$ is
% undefined or defined respectively.  It is used in
% $\!\addcontentsonly!\<t\>\<c\>$ to stop the execution if
% $|\pcol@ac@def@|{\cdot}t$ is not defined.
% 
% \SpecialArrayIndex{t}{\pcol@ac@def@}
% 
% \item[\Uidx{$\!\@ifnextchar!\arg{char}\arg{then}\arg{else}$}]
% is an internal macro to do $\arg{then}$ or $\arg{else}$ if the character
% following to the macro is $\arg{char}$ or not respectively.  It is used in
% \!\paracol!, the initial definition of \!\pcol@com@column*!,
% \!\pcol@com@switchcolumn! and \!\pcol@iswitchcolumn! to examine if they
% are followed by a `|[|'.
% 
% \item[\Uidx{$\!\@ifstar!\arg{then}\arg{else}$}]
% is an internal macro to do $\arg{then}$ or $\arg{else}$ if the character
% following to the macro is `|*|'.  It is used in \!\pcol@switchcolumn! to
% examine if the optional `|*|' is specified.
% 
% \item[\Uidx{$\!\@whilesw!\arg{sw}\cs{fi}\arg{body}$}]
% is an internal macro to iterate $\arg{body}$ while the switch $\arg{sw}$
% is $\true$.  It is used in \!\pcol@output!, \!\pcol@startpage!,
% \!\pcol@output@clear!, \!\pcol@flushfloats!, \!\pcol@freshpage! and
% \!\pcol@output@end! to iterate building of \fcolumn{}s or \fpage{}s while
% $\CSIndex{if@fcolmade}=\true$.
% 
% \item[\Uidx{$\!\@whilenum!\arg{ifnum}\cs{do}\arg{body}$}]
% is an internal macro to interate $\arg{body}$ while the integer comparison
% expression $\arg{ifnum}$ is $\true$.  The macro is used in the following
% macros to iterate their own procedures for all columns $c\In0\C$.
% 
% \begin{quote}\raggedright
% \!\pcol@checkshipped!,
% \!\pcol@outputelt!,
% \!\pcol@output@start!,
% \!\pcol@output@switch!,
% \!\pcol@sync!,
% \!\pcol@makeflushedpage!,
% \!\pcol@flushfloats!,
% \!\pcol@freshpage!,
% \!\pcol@output@end!,
% \!\pcol@synccounter!,
% \!\pcol@com@syncallcounters!,
% \!\pcol@stepcounter!
% \end{quote}
% 
% The macro is also used in \!\pcol@flushcolumn! to iterate building
% \fcolumn{}s of a column $c$ in pages $q$ such that
% $q\in(\cc_c(\vb^p),\ptop)$.
% 
% \item[\Uidx{$\!\@next!\arg{elm}\arg{lst}\arg{suc}\arg{fail}$}]
% is an internal macro to remove the first element from $\arg{lst}$,
% \!\def!ine $\arg{elm}$ to have the first element, and then do $\arg{suc}$,
% if $\arg{lst}$ is not empty.  Otherwise, it performs $\arg{fail}$.  The
% macro is used in the following macros to obtain an \!\insert! from
% \!\@freelist!.
% 
% \begin{itemize}
% \item
% \!\pcol@opcol! for the completed \colpage{}.
% 
% \item
% \!\pcol@startpage! for \fpage{}s and \spanning{} for multi-column top
% floats.
% 
% \item
% \!\pcol@output@start! for the \preenv{} and \colpage{}s of all columns.
% 
% \item
% \!\pcol@output@switch! for the \colpage{} from which we are leaving, and
% for footnotes in it if exist.
% 
% \item
% \!\pcol@flushcolumn! for \fcolumn{}s and the empty \colpage{} in $\ptop$.
% 
% \item
% \!\pcol@synccolumn! for an \mvlfloat{} on a \sync{}ation if its point
% defined by a column whose main vertical list is empty.
% 
% \item
% \!\pcol@output@end! for the multi-column floats in the \lpage{} if the
% main vertical list of the page is empty.
% \end{itemize}
% 
% The macro is also used in \!\pcol@outputelt! to obtain completed
% \colpage{}s from $\S_c$.
% 
% \item[\Uidx{$\!\@cons!\arg{lst}\arg{elm}$}]
% is an internal macro to add $\!\@elt!\arg{elm}$ to the tail of $\arg{lst}$.
% 
% \begin{itemize}
% \item
% \!\pcol@opcol! to add the completed \ccolpage{} of $c$ to $\S_c$.
% 
% \item
% \!\pcol@startpage! to add \fpage{}s to $\PP$.
% 
% \item
% \!\pcol@outputelt! to return shipped-out pages, \spanning{} and
% \colpage{}s to \!\@freelist!, or to add $\pp(q)$ to $\PP$ if the page $q$
% is kept.
% 
% \item
% \!\pcol@output@start! to return the \ccolpage{} of 0 to \!\@freelist!.
% 
% \item
% \!\pcol@restartcolumn! to return the \ccolpage{} 
% to be resumed, and its footnotes if any, to \!\@freelist!.
% 
% \item
% \!\pcol@flushcolumn! to return footnotes in the \ccolpage{} of $c$ to be
% flushed to \!\@freelist! if any, and to add the flushed \colpage{} and
% \fcolumn{}s to $\S_c$.
% 
% \item
% \!\pcol@makefcolelt! to add a float to \!\@toplist! or $\cc_c(\dl)$.
% 
% \item
% \!\pcol@synccolumn! to add an \mvlfloat{} for \sync{}ation to
% $\cc_c(\tl)$.
% 
% \item
% \!\pcol@makeflushedpage! to return \spanning{} to \!\@freelist!, and to
% return footnotes in the \colpage{} to be flushed to \!\@freelist! if any.
% 
% \item
% \!\pcol@output@end! to return all \ccolpage{}s to \!\@freelist!.
% 
% \item
% $\!\globalcounter!\<\theta\>$ to add a \gcounter{} $\theta$ to $\CG$.
% 
% \item
% $\!\pcol@iremctrelt!\<\theta\>$ to add \lcounter{} $\theta$ to $\CL$.
% 
% \item
% $\!\pcol@storectrelt!\<\theta\>$ to add $\<\theta,\val_c(\theta)\>$ to
% $\Cc_c$ for a column $c$.
% 
% \item
% $\!\pcol@savectrelt!\<\theta\>$ to add $\<\theta,\val(\theta)\>$ to
% $\Cc_c$ for a column $c$.
% 
% \item
% $\!\pcol@cmpctrelt!\<\theta\>$ to add $\theta$ to the list of \lcounter{}s
% to be synchronized.
% 
% \item
% $\!\addcontentsonly!\<t\>\<c\>$ to add $\<t,c\>$ to $\T$.
% \end{itemize}
% 
% \item[\Uidx{$\!\@cdr!\<a_1\>\<a_2\>\cdots\<a_n\>\cs{@nil}$}]
% is an internal macro to be expanded to $\<a_2\>\cdots\<a_n\>$. It is used
% in $\!\pcol@getcurrpinfo!\arg{cs}$ to extract $\pp(\ptop)$ from
% $\!\pcol@currpage!=\!\@elt!\Arg{\pp(\ptop)}$ and to \!\def!ine $\arg{cs}$
% letting it have $\pp(\ptop)$.
% 
% \item[\Uidx{\!\@eha!}]
% is an internal macro having a help message saying the command causing an
% error is ignored.  It is used in \!\paracol!, \!\pcol@switchcolumn!,
% \!\pcol@switchenv!, and \!\addcontentsonly! as the argument of
% \!\PackageError!.
% 
% \item[\Uidx{\!\@ehb!}]
% is an internal macro having a help message saying the error causes a
% serious problem.  It is used in \!\pcol@ovf! as the argument of
% \!\PackageError!.
% 
% \item[\Uidx{$\!\@latex@warning@no@line!\arg{msg}$}]
% is an internal macro to report a warning message $\arg{msg}$ without the
% line number in which the cause lies.  It is used \!\pcol@output! in case
% that a page with floats and very short main vertical list is built.
% 
% \item[\Uidx{\!\color@begingroup!}]
% is an internal macro to open a group in which a color is specified.  It is
% used in \!\pcol@makenormalcol! to enclose footnotes with \!\normalcolor!
% for \preenv{}.
% 
% \item[\Uidx{\!\color@endgroup!}]
% is an internal macro to close a group in which a color is specified.  It is
% used in \!\pcol@makenormalcol! to enclose footnotes with \!\normalcolor!
% for \preenv{}.
% 
% \item[\Uidx{$\!\@stpelt!\<\theta\>$}]
% is an internal macro to zero-clear the counter $\theta$ for the
% implementation of \!\stepcounter!.  It is used in \!\pcol@stepcounter! to
% clear the descendent counters of a \gcounter{} $\cg$ listed in
% $|\pcol@cl@|{\cdot}\cg$.
% 
% \SpecialArrayIndex{\theta}{\pcol@cl@}
% 
% \item[\Uidx{\!\@sect!}]
% is an internal macro to implement sectioning commands.  The original
% definition of the macro is kept in \!\pcol@ac@enable@toc!, while
% \!\pcol@ac@def@toc! makes it \!\let!-equal to \!\pcol@ac@enable@toc! or
% \!\pcol@ac@disable@toc!, the latter of which uses the original version
% kept in \!\pcol@ac@enable@toc! after disabling \!\addcontentsline!.
% 
% \item[\Uidx{\!\@caption!}]
% is an internal macro to implement \!\caption!.  The original definition of
% the macro is kept in \!\pcol@ac@caption@latex!, while
% \!\pcol@ac@caption@def! makes it \!\let!-equal to \!\pcol@ac@caption!
% which uses the original version kept in \!\pcol@ac@enable@toc! after
% disabling \!\addcontentsline! if necessary.
% 
% \item[\Uidx{\!\ext@figure!}]
% is an internal macro having ``|lof|'' being the extention of the file for
% list of figures.  It is used in
% $\!\pcol@ac@caption!\arg{type}|[|\arg{lcap}|]|\<cap\>$ to have ``|lof|''
% when $\arg{type}=|figure|$.
% 
% \item[\Uidx{\!\ext@table!}]
% is an internal macro having ``|lot|'' being the extention of the file for
% list of tables.  It is used in
% $\!\pcol@ac@caption!\arg{type}|[|\arg{lcap}|]|\<cap\>$ to have ``|lot|''
% when $\arg{type}=|table|$.
% 
% \item[\Uidx{\!\@specialoutput!}]
% is an internal macro for \!\output! routine to process an \!\output!
% request made by \LaTeX's original \!\clearpage! and $\!\end!\Arg{float}$.
% It is used in \!\pcol@specialoutput! to process the request for floats.
% 
% \item[\Uidx{\!\@makecol!}]
% is an internal macro for \!\output! routine to build the shipping-out
% image of a column in \!\@outputbox! consisting of top floats, main
% vertical list in \!\box!|255|, footnotes in \!\footins!, and bottom
% floats.  It is used in \!\pcol@makecol! for an ordinary \colpage{},
% in \!\pcol@flushcolumn! for a \ccolpage{} to be flushed, and in
% \!\pcol@makeflushedpage! for \colpage{}s in $\ptop$ to be flushed.
% 
% \item[\Uidx{\!\@combinefloats!}]
% is an internal macro for \!\output! routine to combine top and bottom
% floats in \!\@toplist! and \!\@botlist! respectively with \!\@outputbox!
% in which the main vertical list and footnotes have been put by
% \!\@makecol!, and to have the result in \!\@outputbox! again.  It is used
% in \!\pcol@makenormalcol! for \preenv{}, while \!\paracol! makes it
% \!\let!-equal to our own \!\pcol@combinefloats! so that \!\@makecol! uses
% it.
% 
% \item[\Uidx{\!\@cflt!}]
% is an internal macro for \!\output! routine to put all top floats in
% \!\@toplist! and related stuff such as the vertical skip of
% \!\textfloatsep! into \!\@outputbox!  together with its old contents being
% the main vertical list and footnotes.  It is used in
% \!\pcol@combinefloats! if the \colpage{} being processed does not have
% \sync{}ation points.
% 
% \item[\Uidx{\!\@cflb!}]
% is an internal macro for \!\output! routine to put all bottom floats in
% \!\@botlist! and related stuff such as the vertical skip of
% \!\textfloatsep! into \!\@outputbox!  together with its old contents being
% top floats, the main vertical list and footnotes.  It is used in
% \!\pcol@combinefloats!.
% 
% \item[\Uidx{$\!\@comflelt!\arg{flt}$}]
% is an internal macro for \!\output! routine to put $\arg{flt}$ being a
% single-column top or bottom float to the tail of \!\@tempboxa! which
% finally has all top\slash bottom floats in a column.  It is used in
% \!\pcol@cflt! to apply to each element of \!\@toplist!.
% 
% \item[\Uidx{\!\@textbottom!}]
% is an internal macro for \!\output! routine to be put at the bottom of
% \!\@outputbox! in which a \colpage{} is stored, by \!\@makecol!.  This
% macro is temporarily re\!\def!ined by \!\pcol@makecol! for a \colpage{}
% having \sync{}ation points so that it has a vertical skip of inifinite
% stretch and shrink to push up/down the staff below the last \sync{}ation
% point in order to adjust its top to the point.  After that, its original
% definition kept in \!\pcol@textbottom! is restored.
% 
% \item[\Uidx{\!\@outputpage!}]
% is an internal macro for \!\output! routine to output a page kept in
% \!\@outputbox! together with the headder and footer.  It is used in
% \!\pcol@outputelt! for ordinary completed pages, in \!\pcol@output@start!
% for (almost) full page \preenv{}, in \!\pcol@output@flush! for the
% flushed \tpage, in \!\pcol@output@clear! for the flushed \tpage{} and
% following \fpage{}s, in \!\pcol@flushfloats! for pages having flushed
% \fcolumn{}s, and in \!\pcol@output@end! for the non-empty \lpage{}
% followed by pages having \fcolumn{}s.
% 
% \item[\Uidx{\!\@dblfloatplacement!}]
% is an internal macro for \!\output! routine to reinitialize multi-column
% float placement paramenters.  It is used in \!\pcol@startpage! and
% \!\pcol@output@clear! prior to processing multi-column floats in
% \!\@dbldeferlist!.
% 
% \item[\Uidx{$\!\@tryfcolumn!\arg{lst}$}]
% is an internal macro for \!\output! routine which examines if a \fcolumn{}
% or a \fpage{} can be built with some floats in $\arg{lst}$ and, if so,
% builds the page in \!\@outputbox! removing floats put in the page from
% $\arg{lst}$.  It is used in \!\pcol@startpage! for multi-column floats in
% \!\@dbldeferlist!, and in \!\pcol@startcolumn! for single-column floats in
% $\cc_c(\dl)$.
% 
% \item[\Uidx{$\!\@sdblcolelt!\arg{flt}$}]
% is an internal macro for \!\output! routine which examines if a
% multi-column float $\arg{flt}$ can be added to \!\@dbltoplist! being the
% list of the floats to be put at the top of a page, and if so, adds
% $\arg{flt}$ to \!\@dbltoplist!, while it is added to \!\@dbldeferlist!
% otherwise.  It is used in \!\pcol@startpage! to apply to each element of
% (the copy of) \!\@dbldeferlist!.
% 
% \item[\Uidx{$\!\@comdblflelt!\arg{flt}$}]
% is an internal macro for \!\output! routine to put $\arg{flt}$ being a
% multi-column float to the tail of \!\@tempboxa! which finally has the
% \spanning{} for multi-column floats.  It is used in \!\pcol@startpage! to
% apply to each element of \!\@dbltoplist! to have the \spanning.
% 
% \item[\Uidx{\!\@floatplacement!}]
% is an internal macro for \!\output! routine to reinitialize single-column
% float placement parameters.  It is used in our own version of it,
% \!\pcol@floatplacement!.
% 
% \item[\Uidx{$\!\@scolelt!\arg{flt}$}]
% is an internal macro for \!\output! routine which examines if a
% single-column float $\arg{flt}$ can be added to \!\@toplist! or
% \!\@botlist! being the list of the floats to be put at the top or bottom
% of a page respectively.  Then, if the examination succeeds, $\arg{flt}$ is
% added to \!\@toplist! or \!\@botlist!, while it is added to
% \!\@deferlist! otherwise.  It is used in \!\pcol@trynextcolumn! to
% apply to each element of (the copy of) $\cc_c(\dl)$.
% 
% \item[\Uidx{$\!\@makefcolumn!\arg{lst}$}]
% is an internal macro for \!\output! routine to build a \fcolumn{} with
% some floats at the head of a float list $\arg{lst}$ and to remove the
% floats from the list.  It is used in \!\pcol@flushcolumn! and
% \!\pcol@flushfloats! for $\cc_c(\dl)$ of single-column floats, and in
% \!\pcol@output@clear! for \!\@dbldeferlist! of multi-column floats which
% become single-column ones.
% 
% \item[\Uidx{\!\@opcol!}]
% is an internal macro for \!\output! routine to output a page or to keep
% the first column until the second one is completed.  This macro is used
% only in \!\pcol@output@end! for the case multi-column floats are left at
% \Endparacol{} and they are put in \fpage{}s.
% 
% \item[\Uidx{\!\@startcolumn!}]
% is an internal macro for \!\output! routine which tries to build a
% \fcolumn{} for the floats in \!\@deferlist! and, if the column
% is not built, tries to move floats to \!\@toplist! and \!\@botlist!.  This
% macro is used only in \!\pcol@output@end! for the case multi-column floats
% are left at \Endparacol{} after which they become single-column ones.
% 
% \item[\Uidx{\!\@emptycol!}]
% is an internal macro for \!\output! routine to put back an empty page to
% the main vertical list.  It is used \!\pcol@output! in case that a page
% with floats and very short main vertical list is built.
% \end{description}
%
% 
% 
% \subsubsection{Structural Macros}
% 
% \begin{description}
% \item[\Uidx{\!\topfraction!}]
% is an API macro to have the maximum fraction of the space for top floats
% in a column.  It is used by \!\pcol@makeflushedpage! to recalculate
% $\!\@toproom!=\cc_c(\tr)=\!\topfraction!\times\pp^h(\ptop)$.
% 
% \item[\Uidx{$\!\@elt!\<a_1\>\cdots\<a_n\>$}]
% is an internal control sequence to represent a list element having $n$
% subelements.  The sequence is often made \!\let!-equal to a macro which
% processes $\<a_1\>\cdots\<a_n\>$ and is applied to all members in a list.
% It is also made \!\let!-equal to \!\relax! on a manipulation of a list,
% such as element addition and concatenation, by \!\edef! or \!\xdef!.  The
% usages of the sequence are as follows.
% 
% \begin{itemize}
% \item
% \!\pcol@cflt! does $\!\@elt!=\!\@comflelt!$ for $\cc_c(\tl)$, and then
% $\!\@elt!=\!\relax!$ to concatenate \!\@freelist! and $\cc_c(\tl)$.
% 
% \item
% \!\pcol@setpageno! does $\!\@elt!=\!\pcol@setpnoelt!$ for $\PP$.
% 
% \item
% \!\pcol@setpnoelt! does $\!\@elt!=\!\relax!$ to add $\pp(q)$ to $\PP$.  It
% also uses \!\@elt! to \!\def!ine \!\pcol@currpage! with
% $\!\@elt!\<\pp(q)\>$ or $\!\@elt!|{|\pp(q)|}|$.
% 
% \item
% \!\pcol@setordpage! does $\!\@elt!=\!\relax!$ to \!\xdef!ine
% \!\pcol@currpage! with $\!\@elt!|{|\pp(q)|}|$.
% 
% \item
% \!\pcol@nextpage! does $\!\@elt!=\!\pcol@nextpelt!$ for $\PPP$.
% 
% \item
% \!\pcol@getcurrpage! does $\!\@elt!=\!\pcol@getpelt!$ for $\PPP$.
% 
% \item
% \!\pcol@startpage! does $\!\@elt!=\!\@sdblcolelt!$ for (the copy of)
% \!\@dbldeferlist!, $\!\@elt!=\!\@comdblflelt!$ for \!\@dbltoplist!,
% and then $\!\@elt!=\!\relax!$ to concatenate \!\@freelist! and
% \!\@dbltoplist!.  It also uses \!\@elt! to \!\xdef!ine \!\pcol@currpage!
% with $\!\@elt!\<\pp(\ptop)\>$.
% 
% \item
% \!\pcol@outputpage! does $\!\@elt!=\!\pcol@outputelt!$ with two arguments
% for (the copy of) $\PP$.
% 
% \item
% \!\pcol@trynextcolumn! does $\!\@elt!=\!\@scolelt!$ for (the copy of)
% $\cc_c(\dl)$.
% 
% \item
% \!\pcol@output@start! uses \!\@elt! to \!\xdef!fine \!\pcol@currpage! with
% $\!\@elt!\<\pp(0)\>$.
% 
% \item
% \!\pcol@makenormalcol! does $\!\@elt!=\!\relax!$ to concatenate
% \!\@freelist! and \!\@midlist!.
% 
% \item
% \!\pcol@setcurrcol! does $\!\@elt!=\!\relax!$ to \!\xdef!ine $\cc_c$ with
% $\cc_c(\tl)=\!\@toplist!$, $\cc_c(\ml)=\!\@midlist!$,
% $\cc_c(\bl)=\!\@botlist!$  and $\cc_c(\dl)=\!\@deferlist!$.
% 
% \item
% \!\pcol@makefcolumn! does $\!\@elt!=\!\pcol@makefcolelt!$ for (the copy
% of) $\cc_c(\dl)$ to examine if each float in it can be put in a \fcolumn{}
% to be built, and then \!\def!ine it to put floats in $\cc_c(\tl)$ into
% $\cc_c(\vb^b)$.
% 
% \item
% \!\pcol@addflhd! does $\!\@elt!=\!\pcol@hdflelt!$ for its argument
% $\cc_c(\tl)$ or $\cc_c(\bl)$, and then $\!\@elt!=\!\relax!$ to give the
% default.
% 
% \item
% \!\pcol@output@end! does $\!\@elt!=\!\relax!$ to add the \spanning{} of
% the last page to the head of \!\@dbldeferlist!.
% 
% \item
% \!\paracol! does $\!\@elt!=\!\pcol@remctrelt!$ for $\CG$,
% $\!\@elt!=\!\pcol@thectrelt!$ for $\CL$, $\!\@elt!=\!\pcol@loadctrelt!$
% for $\Cc_0$, $\!\@elt!=\!\pcol@cmpctrelt!$ for $\CL$,
% $\!\@elt!=\!\pcol@defcomelt!$ for \!\pcol@localcommands!, and then
% $\!\@elt!=\!\relax!$ to give the default.
% 
% \item
% \!\pcol@localcommands! has the sequence of $\!\@elt!\ARg{com}$ for all
% \lcommand{}s $|\|\arg{com}$.
% 
% \item
% \!\pcol@gcounters! has \!\@elt!|{page}| as its initial definition.
% 
% \item
% \!\pcol@remctrelt! does $\!\@elt!=\!\pcol@iremctrelt!$ for (the copy of)
% $\CL$.
% 
% \item
% $\!\pcol@sscounters!\arg{elt}$ does $\!\@elt!=\arg{elt}$, where
% $\arg{elt}=\!\pcol@storectrelt!$ or $\arg{elt}=\!\pcol@savectrelt!$, for
% $\CL$, and then $\!\@elt!=\!\relax!$ to \!\xdef!ine $\Cc_c$.
% 
% \item \begingroup\hfuzz1.4pt
% $\!\pcol@com@synccounter!\<\theta\>$ gives $\!\@elt!\Arg{\theta}$ as the
% argument of |\pcol@synccounter|.
% 
% \SpecialIndex{\pcol@synccounter}
% \par\endgroup
% 
% \item \begingroup\hfuzz0.37pt
% $\!\pcol@synccounter!\arg{lst}$ does $\!\@elt!=\!\relax!$ to have the list
% $\arg{lst}$ in \!\reserved@a! by \!\edef!, $\!\@elt!=\!\pcol@loadctrelt!$
% for $\CC_c$, and then $\!\@elt!=\!\pcol@syncctrelt!$ for $\arg{lst}$.
% \par\endgroup
% 
% \item
% $\!\pcol@stepcounter!\<\theta\>$ does $\!\@elt!=\!\pcol@stpldelt!$ for
% $\CL$, $\!\@elt!=|\pcol@|\~|stpclelt|$
% 
% \SpecialIndex{\pcol@stpclelt}
% 
% for $\clist(\theta)$, and then $\!\@elt!=\!\@stpelt!$ for
% $\clist(\theta)$.
% 
% \item
% \!\pcol@switchcol! does $\!\@elt!=\!\pcol@setctrelt!$ for $\CC_c$,
% $\!\@elt!=|\pcol@|\~|aconlyelt|$
% 
% \SpecialIndex{\pcol@aconlyelt}
% 
% for $\T$, and then $\!\@elt!=\!\relax!$ to give the default.
% \end{itemize}
% 
% \item[\Uidx{\!\@empty!}]
% is a macro always having nothing.  Its major usages are to examine if a
% macro often having a list is empty, and to make such a macro empty.  The
% following macros use \!\@empty! to examine the emptiness of the objects in
% parentheses.
% 
% \begin{quote}
% \!\pcol@combinefloats! ($\cc_c(\tl)$, $\cc_c(\bl)$)\\
% \!\pcol@checkshipped! ($S_c$)\\
% \!\pcol@startpage! ($\pp(\ptop)$, \!\@dbltoplist!)\\
% \!\pcol@flushcolumn! ($\cc_c(\dl)$)\\
% \!\pcol@makefcolumn! ($\cc_c(\dl)$, $\cc_c(\tl)$)\\
% \!\pcol@measurecolumn! ($\cc_c(\bl),\cc_c(\dl)$)\\
% \!\pcol@addflhd! ($\cc_c(\tl)$, $\cc_c(\tl)$)\\
% \!\pcol@synccolumn! ($\cc_c(\tl)$)\\
% \!\pcol@makeflushedpage! ($\cc_c(\dl)$)\\
% \!\pcol@flushfloats! ($\cc_c(\dl)$)
% \end{quote}
% 
% The following macros use \!\@empty! to empty the objects in parentheses.
% 
% \begin{quote}
% \!\pcol@cflt! ($\cc_c(\tl)$)\\
% \!\pcol@setpageno! ($\PP$, $\pp(\ptop)$)\\
% \!\pcol@startpage! ($\cc_c(\dl)$, \!\@dbltoplist!)\\
% \!\pcol@trynextcolumn! ($\cc_c(\dl)$)\\
% \!\pcol@output@start! ($\PP$, $\pp(\ptop)$, $\cc_c(\dl)$)\\
% \!\pcol@makenormalcol! (\!\@midlist!)\\
% \!\pcol@flushcolumn! ($\cc_c(\dl)$)\\
% \!\pcol@makefcolumn! ($\cc_c(\dl)$, $\cc_c(\tl)$)\\
% \!\pcol@makeflushedpage! ($\cc_c(\tl)$)\\
% \!\pcol@freshpage! ($\PP$, $\pp(\ptop)$)\\
% \!\paracol! (\!\@gtempa!)\\
% \!\pcol@remctrelt! ($\CL$)\\
% \!\pcol@sscounters! ($\Cc_c$)
% \end{quote}
% 
% \item[\Uidx{\!\@currbox!}]
% is an internal macro which conventionally has an \!\insert! for floats,
% etc.  The follwing macros use \!\@currbox! having the objects in
% parentheses.
% 
% \begin{quote}
% \!\pcol@opcol! ($\cc_c(\vb)$)\\
% \!\pcol@startpage! ($\pp(\ptop)$)\\
% \!\pcol@outputelt! ($\pp(q)$, $\s_c(q)$)\\
% \!\pcol@output@start! ($\pp(0)$, $\cc_c(\vb)$)\\
% \!\pcol@output@switch! ($\cc_c(\vb)$)\\
% \!\pcol@restartcolumn! ($\cc_c(\vb)$)\\
% \!\pcol@igetcurrcol! ($\cc_c(\vb)$)\\
% \!\pcol@setcurrcol! ($\cc_c(\vb)$)\\
% \!\pcol@sync! ($\pp(\ptop)$)\\
% \!\pcol@flushcolumn! ($\cc_c(\vb), \s_c(q)$)\\
% \!\pcol@measurecolumn! ($\cc_c(\vb)$)\\
% \!\pcol@synccolumn! ($\cc_c(\vb)$)\\
% \!\pcol@makeflushedpage! ($\pp(\ptop)$, $\cc_c(\vb)$)\\
% \!\pcol@freshpage! ($\cc_c(\vb)$)\\
% \!\pcol@output@end! (top float, $\cc_c(\vb)$)
% \end{quote}
% 
% \item[\Uidx{\!\@freelist!}]
% is an internal macro having available \!\insert!s for floats originially,
% but also \colpage{}s, pages and footonotes in our usage.  Besides the
% acquisition of an \!\insert! from it shown in the description of
% \!\@next!, it is used by the following macros to return the the objects in
% parentheses to \!\@freelist!.
% 
% \begin{quote}
% \!\pcol@cflt! ($\cc_c(\tl)$)\\
% \!\pcol@startpage! (\!\@dbltoplist!)\\
% \!\pcol@outputelt! ($\pp(q)$, $\s_c(q)$)\\
% \!\pcol@output@start! ($\cc_0(\vb)$)\\
% \!\pcol@makenormalcol! (\!\@midlist!)\\
% \!\pcol@restartcolumn! ($\cc_c(\vb)$, $\cc_c(\ft)$)\\
% \!\pcol@flushcolumn! ($\cc_c(\ft)$)\\
% \!\pcol@makefcolumn! ($\cc_c(\tl)$)\\
% \!\pcol@makeflushedpage! ($\pp(\ptop)$, $\cc_c(\ft)$, $\cc_c(\tl)$)\\
% \!\pcol@output@end! ($\cc_c(\vb)$)
% \end{quote}
% 
% \item[\Uidx{\!\@nil!}]
% is an internal control sequence which is conventionally used to terminate
% a variable length argument.  It is used in \!\pcol@getcurrpinfo! for the
% invocation of \!\@cdr!.
% 
% \item[\Uidx{\!\@dbldeferlist!}]
% is an internal macro having the list of multi-column floats whose page
% appearance are not yet fixed.  It is scanned and then updated in
% \!\pcol@startpage! and \!\pcol@output@clear!, while \!\pcol@output@start!
% lets it have \!\@deferlist! made before \beginparacol, and
% \!\pcol@output@end! adds multi-column floats to be put in the empty
% \lpage{} to it and then move the whole of the list to \!\@deferlist!.
% 
% \item[\Uidx{\!\@dbltoplist!}]
% is an internal macro having the list of multi-column floats which
% \!\@sdblcolelt! decided to be put in the new page.  The macro
% \!\pcol@startpage! scans it to put all floats in the page $\ptop$, and then
% empties it after returning all floats to \!\@freelist!.
% 
% \item[\Uidx{\!\@deferlist!}]
% is an internal macro having the list of single-column floats whose page
% appearance are not yet fixed.  It is scanned and then updated in
% \!\pcol@startcolumn!, \!\pcol@trynextcolumn!, \!\pcol@flushcolumn!,
% \!\pcol@makefcolumn! and \!\pcol@flushfloats!, while the following macros
% also act on it.
% 
% \begin{itemize}
% \item
% \!\pcol@output@start! moves it to \!\@dbldeferlist! because it is created
% before \beginparacol.
% 
% \item
% \!\pcol@setcurrcol! and \!\pcol@igetcurrcol! saves\slash restores it
% in/from $\cc_c(\dl)$, respectively.
% 
% \item
% \!\pcol@measurecolumn! examines its emptiness to make $\VP=\pp^h(\ptop)$
% if not empty.
% 
% \item
% \!\pcol@makeflushedpage! examines its emptiness to remember whether any
% floats are deferred for \!\pcol@output@end!.
% 
% \item
% \!\pcol@output@end! lets it have \!\@dbldeferlist! so that it processed as
% sigle-float floats after \Endparacol.
% \end{itemize}
% 
% \item[\Uidx{\!\@toplist!}]
% is an internal macro having the list of single-column floats which is
% decided to be put at the top of the \ccolpage{} by float environments or by
% \!\pcol@trynextcolumn!.  This list is scanned by \!\pcol@cflt! if its
% invoker \!\pcol@combinefloats! finds the macro is not empty.  The list is
% also scanned by \!\pcol@measurecolumn! for the measurement of the combined
% size of top floats, while \!\pcol@setcurrcol! and \!\pcol@igetcurrcol!
% saves\slash restores the list in/from $\cc_c(\tl)$ respectively.  In
% addition our macros may add an element or build the entire list in the
% following two cases.  One case is for a \sync{}ation for which
% \!\pcol@synccolumn! lets the main vertical list in $\cc_c(\vb^b)$ be a
% float, namely {\em\mvlfloat} to be added to this list.  Another case is for
% a \fcolumn{} in the \lpage{} for which \!\pcol@makefcolumn! and
% \!\pcol@makefcolelt! build this list for deferred floats.  In the latter
% case, the list is scanned by \!\pcol@makefcolumn! itself or by
% \!\pcol@makeflushedpage!.
% 
% \item[\Uidx{\!\@botlist!}]
% is an internal macro having the list of single-column floats which is
% decided to be put at the bottom of the \ccolpage{} by float environments or
% by \!\pcol@trynextcolumn!.  The emptiness of this list examined by
% \!\pcol@combinefloats! to invokes the scanner \!\@cflb! unless empty.  The
% list is also scanned by \!\pcol@measurecolumn! for the measurement of the
% combined size of bottom floats, while \!\pcol@setcurrcol! and
% \!\pcol@igetcurrcol! saves\slash restores the list in/from $\cc_c(\bl)$
% respectively.
% 
% \item[\Uidx{\!\@midlist!}]
% is an internal macro having the list of in-text floats which has already
% been put in the \ccolpage{} but is kept to check the ordering of the
% succeeding floats.  The list is emptied by \!\pcol@makenormalcol! after
% returning all elements in it to \!\@freelist!, while \!\pcol@setcurrcol!
% and \!\pcol@igetcurrcol! saves\slash restores the list in/from
% $\cc_c(\ml)$ respectively.
% 
% \item[\Uidx{\!\cl@@ckpt!}]
% is an internal macro having the list of all counters defined by
% \!\newcounter! and the counter \counter{page}.  The original usage of this
% macro is to log the values of all counters into |.aux| by \!\include!, but
% we use it to obatin all counters in \!\paracol!.
% 
% \item[$\cs{cl@}{\cdot}\theta$]
% is an internal macro having the list $\clist(\theta)$ of descendant
% counters of the counter $\theta$ whose increment by \!\stepcounter! lets
% them 0.  The macro \!\pcol@remctrelt! moves it to
% $|\pcol@cl@|{\cdot}\theta$
% 
% \Uidx{\SpecialArrayIndex{\theta}{\cl@}}
% 
% and re\!\def!ines it to have $\!\pcol@stepcounter!\Arg{\theta}$.
% 
% \item[\Uidx{\!\reserved@a!}]
% is an internal macro for temporary use.  Its usages are as follows.
% 
% \begin{itemize}
% \item
% In \!\pcol@setpageno!, it has $\PPP$ so that we update $\PP$ and
% $\pp(\ptop)$ scanning their original contents.
% 
% \item
% In \!\pcol@specialoutput!, it is \!\let!-equal to $|\pcol@output@|{\cdot}f$
% corresponding to $\!\outputpenalty!=|\pcol@op@|{\cdot}f$, or
% \!\@specialoutput!.
% 
% \item
% In \!\pcol@flushcolumn!, it is used to throw $\pp^b(\ptop)$ away because
% we don't need it.
% 
% \item
% In $\!\pcol@defcomelt!\arg{com}$, it is used to implement
% $\!\let!|\|\arg{com}=|\pcol@com@|{\cdot}\~\arg{com}$.
% 
% \item
% In $\!\pcol@remctrelt!\<\theta\>$, it is used to implement
% $\!\let!|\pcol@cl@|{\cdot}\theta=|\cl@|{\cdot}\theta$,
% 
% \SpecialArrayIndex{\theta}{\pcol@cl@}\SpecialArrayIndex{\theta}{\cl@}
% 
% and then it has $\theta$ for the \CSIndex{ifx}-comparison in
% \!\pcol@iremctrelt!.
% 
% \item
% In $\!\pcol@thectrelt!\<\theta\>$, it is used to implement
% $\!\let!|\pcol@thectr@|{\cdot}\theta=|\the|{\cdot}\theta$,
% 
% \SpecialArrayIndex{\theta}{\pcol@thectr@}\SpecialArrayIndex{\theta}{\the}
% 
% and then is made \!\let!-equal to $|\pcol@thectr@|{\cdot}\theta{\cdot}0$.
% 
% \SpecialArrayIndex{\theta{\cdot}c}{\pcol@thectr@}
% 
% \item
% In $\!\pcol@synccounter!\arg{lst}$, it has $\arg{lst}$.
% 
% \item
% In $\!\pcol@setctrelt!\<\theta\>\<\val_c(\theta)\>$, it is made
% \!\let!-equal to $|\pcol@thectr@|{\cdot}\theta$
% 
% \SpecialArrayIndex{\theta}{\pcol@thectr@}
% 
% or
% $|\pcol@thectr@|{\cdot}\theta{\cdot}c$.
% 
% \SpecialArrayIndex{\theta{\cdot}c}{\pcol@thectr@}
% \end{itemize}
% 
% \item[\Uidx{\!\reserved@b!}]
% is an internal macro for temporary use.  It is used in the following
% macros to keep a list shown in paraentheses so that we update the list in
% the scan of list elements. 
% 
% \begin{quote}
% \!\pcol@startpage! (\!\@dbldeferlist!)\\
% \!\pcol@outputpage! ($\PP$)\\
% \!\pcol@trynextcolumn! ($\cc_c(\dl)$)\\
% \!\pcol@makefcolumn! ($\cc_c(\dl)$)\\
% \!\pcol@remctrelt! ($\CC$)
% \end{quote}
% 
% In addition, $\!\pcol@iremctrelt!\<\theta\>$ uses it to have $\theta$ in
% it for \CSIndex{ifx}-comparison.
% 
% \item[\Uidx{\!\@gtempa!}]
% is an internal macro used as a \!\global!ly modifiable scratchpad.  Its
% usages are as follows.
% 
% \begin{itemize}
% \item
% In \!\pcol@measurecolumn!, it has \!\lastpenalty! in a \!\vbox! whose
% value is examined outside the \!\vbox! for the empty check of
% $\cc_c(\vb^b)$.
% 
% \item
% In \!\paracol! and \!\pcol@cmpctrelt!, it has the list of counters to be
% synchronized.
% 
% \item
% \!\pcol@savectrelt! and \!\pcol@sscounters!, it has the new version of
% $\CC_c$.
% \end{itemize}
% \end{description}
% 
% 
% 
%\iffalse
%<*paracol>
%\fi
% 
% \section{Register Declaration}
% \label{sec:imp-decl}
% 
% \subsubsection{\cs{count} Registers}
% 
% Here we declare registers and switches.  The first group is for \!\count!
% registers.
% 
% \begin{macro}{\pcol@currcol}
% The register \!\pcol@currcol! has the zero-origin ordinal $c$ of the
% column which we were in when \!\output! is invoked.  Therefore, for
% example, in the process of \!\switchcolumn!, the register has $c$ from
% which we are switching to another column.  The register is initialized to
% be 0 by \!\pcol@output@start!, and then set to $\!\pcol@nextcol!=d$ by
% \!\pcol@restartcolumn! to switch to (or stay in) $d$.  Note that these two
% assignments are \!\global! while other macros may {\em locally} use the
% register to, for example, scan all columns $c\In0\C$.  Besides two macros
% above, the following macros refer to the register to know which column we
% are in (or which column is processed by their invokers).
% 
% \begin{quote}\raggedright
% \!\pcol@opcol!,
% \!\pcol@output@switch!,
% \!\pcol@getcurrcol!,
% \!\pcol@setcurrcol!,
% \!\pcol@sscounters!,
% \!\pcol@setctrelt!,
% \!\pcol@com@switchcolumn!,
% \!\pcol@switchcol!,
% \!\pcol@aconlyelt!,
% \!\pcol@com@flushpage!,
% \!\pcol@com@clearpage!.
% \end{quote}
% 
% The following macros use the register for the scan of all $c\In0\C$ by
% themselves or their invokers.
% 
% \begin{quote}\raggedright
% \!\pcol@output@start!,
% \!\pcol@output@switch!,
% \!\pcol@sync!,
% \!\pcol@flushcolumn!,
% \!\pcol@measurecolumn!,
% \!\pcol@synccolumn!,
% \!\pcol@makeflushedpage!,
% \!\pcol@flushfloats!,
% \!\pcol@freshpage!,
% \!\pcol@output@end!,
% \!\pcol@synccounter!,
% \!\pcol@com@syncallcounters!,
% \!\pcol@stepcounter!.
% \end{quote}
% 
% \end{macro}
% 
% \begin{macro}{\pcol@nextcol}
% The register \!\pcol@nextcol! has the zero-origin ordinal $d$ of the
% column to which we are switching, or in which we are staying.  The main
% usage of the register is to set the switching target in
% \!\pcol@switchcolumn!, but other macros use it to specify the (temporary)
% target of \!\pcol@switchcol!; 0 in \!\paracol!, \!\pcol@mctext!,
% \!\endparacol!; and $c=\!\pcol@currcol!$ in \!\pcol@com@flushpage! and
% \!\pcol@com@clearpage! to stay in the current column $c$.
% \end{macro}
% 
% \begin{macro}{\pcol@ncol}
% The register \!\pcol@ncol! has the number of columns $\C$ given as the
% argument of \!\paracol! being the sole modifier of the register.  The
% following macros refer to the register to scan all columns $c\In0C$.
% 
% \begin{quote}\raggedright
% \!\pcol@checkshipped!,
% \!\pcol@outputelt!,
% \!\pcol@output@start!,
% \!\pcol@output@switch!,
% \!\pcol@sync!,
% \!\pcol@makeflushedpage!,
% \!\pcol@flushfloats!,
% \!\pcol@freshpage!,
% \!\pcol@output@end!,
% \!\pcol@synccounter!,
% \!\pcol@com@syncallcounters!,
% \!\pcol@stepcounter!,
% \end{quote}
% 
% The other references are made by \!\pcol@com@switchcolumn! and
% \!\pcol@switchcolumn! to examine $c<\C$.
% \end{macro}
% 
% \begin{macro}{\pcol@page}
% The register \!\pcol@page! has the zero-orgin ordinal $p$ of the page
% which we are in.  The register is intialized to be 0 not only by
% \!\pcol@output@start! to give the obvious starting point, but also by
% \!\pcol@freshpage! for page flushing which clears $\PP=\!\pcol@pages!$ to
% give us another type of starting point.  Then the register is incremented
% by \!\pcol@nextpage! to advance one page, by \!\pcol@nextpelt! to skip a
% \fpage, by \!\pcol@startpage! to start a new page, and by
% \!\pcol@output@clear! for pages of \fcolumn{}s and \fpage{}s.  The other
% type of updates of the register is done by \!\pcol@restartcolumn! which
% let $p$ be $\cc_c(\vb^p)$ when we revisit the column $c$ belonging to the
% page $p$.  Note that, besides these \!\global!  updates,
% \!\pcol@flushcolumn! locally updates the register to scan
% $\PP=\!\pcol@pages!$, and \!\pcol@freshpage! also performs local updates
% but in more weird manner.  Besides the updates discussed above, the
% macros \!\pcol@opcol!, \!\pcol@setpageno!, \!\pcol@getcurrpage! and
% \!\pcol@output@switch! refer to the register to know which page they are
% operating on.
% \end{macro}
% 
% \begin{macro}{\pcol@basepage}
% The register \!\pcol@basepage! has the ordinal $\pbase$ of the \bpage{}
% being the oldest page not shipped out yet.  The register is initialized to
% be 0 by \!\pcol@output@start! and \!\pcol@freshpage! together with
% \!\pcol@page!, and then incremented by \!\pcol@outputelt! when it ships
% the page $\pbase$ out.  The macros \!\pcol@setpageno!, \!\pcol@nextpage!
% and \!\pcol@getcurrpage! refer to the register in their scans of $\PP$ or
% $\PPP$ to know the zero-origin ordinal of the element for the current page
% $p$ is $p-\pbase$.
% \end{macro}
% 
% \begin{macro}{\pcol@toppage}
% \changes{v1.0}{2011/10/10}
%	{Renamed from \cs{pcol@maxpage}.}
% 
% The register \!\pcol@toppage! has the ordinal $\ptop$ of the \tpage{}
% having the most advanced \colpage{}s, or {\em\Uidx\lcolpage{}s} in short.
% The register is initialized to be 0 by \!\pcol@output@start! and
% \!\pcol@freshpage! together with \!\pcol@page!, and then let be
% $p=\!\pcol@page!$ by \!\pcol@startpage! to start a new page $p$.  The
% macro \!\pcol@opcol! refers to the register to examine if the \ccolpage{}
% explores a new page, while \!\pcol@flushcolumn! examines if the
% \ccolpage{} is behind the top page.
% \end{macro}
% 
%    \begin{macrocode}

%% Register Declaration

\newcount\pcol@currcol
\newcount\pcol@nextcol
\newcount\pcol@ncol
\newcount\pcol@page
\newcount\pcol@basepage
\newcount\pcol@toppage
%    \end{macrocode}
% 
% 
% 
% \subsubsection{Switches}
% 
% The second declaration group is for switches.
% 
% \begin{macro}{\ifpcol@nospan}
% \changes{v1.0}{2011/10/10}
%	{Renamed from \cs{pcol@textonly}.}
% 
% The switch |\ifpcol@nospan| is true iff a page $p$ does not have
% \spanning, i.e., $\pp(p)<0$ or $\pp(p)\geq256$.  It is set by
% \!\pcol@setpnoelt! for its local use, and by \!\pcol@getpinfo! for the
% examination in \!\pcol@outputelt!, \!\pcol@makeflushedpage! and
% \!\pcol@output@end!.
% \end{macro}
% 
% \begin{macro}{\ifpcol@sync}
% \changes{v1.0}{2011/10/10}
%	{Add initialization to be $\mathit{false}$.}
% 
% The switch |\ifpcol@sync| is true iff \!\pcol@output@switch! is invoked
% from \!\pcol@mctext! or \!\pcol@iswitchcolumn! via \!\output! for
% \sync{}ing column switching.  Besides being turned true by these macros,
% the switch is turned false by \!\pcol@sync! after the \sync{}ation to give
% the default state.
% \end{macro}
% 
% \begin{macro}{\ifpcol@mctext}
% \changes{v1.0}{2011/10/10}
%	{Introduced to restrict the broadcast of \cs{if@nobreak} and
%	 \cs{everypar} only when a column-switching is accompanied with
%	 multi-column text.}
% 
% The switch |\ifpcol@mctext| is true iff \!\pcol@output@switch! is invoked
% from \!\pcol@mctext! to put \mctext.  The switch is turned false by
% \!\pcol@output@switch! to give the default state after it examines the
% switch to {\em broadcast} \CSIndex{if@nobreak} and \!\everypar! to all
% columns if true.
% \end{macro}
% 
% \begin{macro}{\ifpcol@clear}
% \changes{v1.0}{2011/10/10}
%	{Add initialization to be $\mathit{false}$.}
% 
% The switch |\ifpcol@clear| is true iff \!\pcol@output@switch! is invoked
% from \!\pcol@make~flushedpage! to flush pages.  The macro
% \!\pcol@makeflushedpage! also turns the switch false after the invocation
% of \!\pcol@output@switch! to give the default state.  The macros
% \!\pcol@sync! and \!\pcol@flushcolumn! being descendats of
% \!\pcol@output@switch! also examine the switch.
% \end{macro}
% 
% \begin{macro}{\ifpcol@outputflt}
% \changes{v1.0}{2011/10/10}
%	{Renamed from \cs{ifpcol@stopoutput} with the reversal.}
% 
% The switch |\ifpcol@outputflt| is used in \!\pcol@outputelt! to know
% whether a \fpage{} is to be shipped out ($\true$) or not.  The switch is
% initialized to be $\true$ by \!\pcol@outputpage! which invokes
% \!\pcol@outputelt! for all $\pp(p)\in\PP$.  Then if \!\pcol@outputpage! is
% invoked from \!\pcol@opcol! to ship the oldest page $\pbase$ out, the
% switch is turned $\false$ when we visit the second non-\fpage.  That is,
% all \fpage{}s following the first (oldest) page are shipped out but others
% are not.  On the other hand, if \!\pcol@outputpage! is invoked from
% \!\pcol@sync! to ship out all pages including \fpage{}s in $\PP$, the
% switch is kept $\true$ throughout all invocations \!\pcol@outputelt!.
% \end{macro}
% 
% \begin{macro}{\ifpcol@lastpage}
% \changes{v1.0}{2011/10/10}
%	{Introduced for special operations in the last page.}
% 
% The switch |\ifpcol@lastpage| is used to know whether they works on the
% {\em\Uidx\lpage} of \env{paracol} environment in the following macros
% to do special operations if so.
% 
% \begin{itemize}
% \item
% \!\pcol@makecol! does not make \!\@textbottom! have inifinite stretch and
% shrink even if the \lpage{} has \sync{}ation point.
% 
% \item
% \!\pcol@combinefloats! adds \!\textfloatsep! below bottom floats of each
% column if any so that the floats are well sepearated from the \postenv.
% 
% \item
% \!\pcol@makefcolumn! trys to make deferred floats as top floats.
% \end{itemize}
% 
% The switch is initialized to be $\false$ by \!\paracol! and then turned
% $\true$ by \!\pcol@output@end! which may also turned it $\false$ again for
% \fpage{}s following the \lpage{} if any.
% \end{macro}
% 
%    \begin{macrocode}
\newif\ifpcol@nospan
\newif\ifpcol@sync \pcol@syncfalse
\newif\ifpcol@mctext \pcol@mctextfalse
\newif\ifpcol@clear \pcol@clearfalse
\newif\ifpcol@outputflt
\newif\ifpcol@lastpage
%    \end{macrocode}
% 
% 
% 
% \subsubsection{\cs{dimen} and \cs{skip} Registers}
% 
% The last declaration group is for three \!\dimen! and one \!\skip!
% registers.
% 
% \begin{macro}{\pcol@prevdepth}
% The \!\dimen! register \!\pcol@prevdepth! is set to the depth of the last
% item added to the main vertical list of column $c$ from which we switch to
% another column $d$, i.e., \!\prevdepth! seen in \!\pcol@invokeoutput!
% before \!\output! request.  The value of the register is then  set into
% \!\prevdepth! also by \!\pcol@invokeoutput! after \!\output! for the
% column $d$.  The value of the register is stored in $\cc_c(\pd)$ by
% \!\pcol@setcurrcol! and then restored into the register by
% \!\pcol@igetcurrcol! for the use in \!\pcol@measurecolumn!.  The register
% is also updated by \!\pcol@synccolumn! for empty main vertical list case,
% and by \!\pcol@output@end!  to be set into \!\prevdepth! for the first
% vertical item of \postenv.
% \end{macro}
% 
% \begin{macro}{\pcol@colht}
% The \!\dimen! register \!\pcol@colht! has the height of the tallest column
% in the \tpage{} $\ptop$ in which an \exsync{} takes place.  The register
% is initialized to be $-\!\maxdimen!$ by \!\pcol@sync! and then is examined
% and updated in \!\pcol@measurecolumn! to find the tallest column.  Besides
% the internal use of this exploration, its result is referred to by
% \!\pcol@makeflushedpage! when it is invokded from \!\pcol@output@end! to
% know the height of the last multi-column stuff of the \env{paracol}
% environment.  The other usage of this register is in \!\pcol@freshpage! to
% keep the value of \!\@colht! of the page made by \!\flushpage! or
% \!\clearpage! so that it is given to $\!\@colroom!=\cc_c(\vb^r)$ of each
% column $c$ in case a column $c'$ s.t.\ $c'<c$ mades another page for
% \fcolumn{}s updating \!\@colht!.
% \end{macro}
% 
% \begin{macro}{\pcol@textfloatsep}
% \changes{v1.0}{2011/10/10}
%	{Introduced for the bug fix of float space enlargement.}
% 
% The \!\dimen! (not \!\skip!) register \!\pcol@textfloatsep! has
% \!\maxdimen! if a \colpage{} does not have \sync{}ation points, to let top
% floats are inserted in usual way.  If it has, the register may hold the
% vertical space amount inserted after top floats in a \colpage{} instead of
% \!\textfloatsep! so that, if a column only with top floats defined the
% first \sync{}ation point, the space for floats are extended to the
% \sync{}ation point.  In this extension case, the register has the amount
% above biased by 10000\,|pt| to distinguish the case from another case with
% ordinary top floats in which the register has non-biased \!\textfloatsep!.
% In addition, if the register is less than \!\maxdimen! including a value
% equal to \!\textfloatsep!, top floats are packed in a \!\vbox! so that
% stretch\slash shrink factor of \!\floatsep!  cannot move \sync{}ation
% points.  After the default setting to be \!\maxdimen! by \!\paracol! and
% \!\pcol@floatplacement!, the value of the register is stored in
% $\cc_c(\tf)$ by \!\pcol@setcurrcol! and then restored into the register by
% \!\pcol@igetcurrcol! for the use in \!\pcol@makecol!,
% \!\pcol@combinefloats!, \!\pcol@cflt!, \!\pcol@measurecolumn!,
% \!\pcol@addflhd! and \!\pcol@synccolumn!.
% \end{macro}
% 
% \begin{macro}{\pcol@topskip}
% The \!\skip! register \!\pcol@topskip! keeps the value of \!\topskip! at
% \beginparacol{} for the ordinary usage of \!\topskip! which may have 0 in
% the starting and \lpage{} temporarily.  After the initialization by
% \!\paracol!, it is referred to by \!\pcol@getpinfo!, \!\pcol@startpage!,
% \!\pcol@output@start! and \!\endparacol!.
% \end{macro}
% 
%    \begin{macrocode}
\newdimen\pcol@prevdepth
\newdimen\pcol@colht
\newdimen\pcol@textfloatsep
\newskip\pcol@topskip

%    \end{macrocode}
% 
% 
% 
% \section{\cs{output} Routine}
% \label{sec:imp-output}
% 
% \begin{macro}{\pcol@ovf}
% Before giving the definitions of macros in \!\output! rontine, we define
% the macro \!\pcol@ovf! invoked if \!\@freelist! is empty on an acquision
% of an \!\insert! by \!\@next! and thus we have to abort the execution by
% \!\PackageError! with a message notifying the shortage.  The additional
% help message is \!\@ehb! as in \!\@fltovf!.  This macro is used in
% \!\pcol@opcol!, \!\pcol@startpage!, \!\pcol@output@start!,
% \!\pcol@output@switch!, \!\pcol@flushcolumn!, \!\pcol@synccolumn! and
% \!\pcol@output@end!.
% \end{macro}
% 
%    \begin{macrocode}
%% \output Routine

\def\pcol@ovf{%
  \PackageError{paracol}{Too many unprocessed columns/floats}\@ehb}

%    \end{macrocode}
% 
% \begin{macro}{\pcol@output}
% The macro \!\pcol@output! is the \Paracol's version of \!\output! which
% is let have this macro as its sole token by \!\paracol!.  The structure of
% this macro is same as that of \LaTeX's \!\output! but the following
% replacements are made.
% 
% \begin{itemize}
% \item
% $\!\@specialoutput!\to\!\pcol@specialoutput!$ to process \Paracol's own
% special output functions, starting first page, \cswitch, page
% flushing with\slash without float flusing, and building the multi-column
% part of the \lpage.
% 
% \item
% \changes{v1.0}{2011/10/10}
%	{Replace \cs{@makecol} with \cs{pcol@makecol} for a special care for
% 	 column-pages with synchronization points.}
% 
% $\!\@makecol!\to\!\pcol@makecol!$ for a special care for \ccolpage{} having
% \sync{}ation point.
% 
% \item
% $\!\@opcol!\to\!\pcol@opcol!$ to hold the \ccolpage{} which just has
% completed.
% 
% \item
% $\!\@startcolumn!\to\!\pcol@startcolumn!$ to creat a new \colpage{}.
% \end{itemize}
% 
%    \begin{macrocode}
\def\pcol@output{\let\par\@@par
  \ifnum\outputpenalty<-\@M
    \pcol@specialoutput
  \else
    \pcol@makecol
    \pcol@opcol
    \pcol@startcolumn
    \@whilesw\if@fcolmade\fi{\pcol@opcol \pcol@startcolumn}%
  \fi
  \ifnum\outputpenalty>-\@Miv
    \ifdim\@colroom<1.5\baselineskip
      \ifdim\@colroom<\textheight
        \@latex@warning@no@line{Text page \thepage\space
                                contains only floats}%
        \@emptycol
      \else
        \global\vsize\@colroom
      \fi
    \else
      \global\vsize\@colroom
    \fi
  \else
    \global\vsize\maxdimen
  \fi}

%    \end{macrocode}
% \end{macro}
% 
% 
% 
% \section{Completing Column-Page}
% \label{sec:imp-opcol}
% 
% \begin{macro}{\pcol@makecol}
% \changes{v1.0}{2011/10/10}
%	{Introduced for special float handling in a column-page with
%	 synchronization point.}
% 
% The macro \!\pcol@makecol! is invoked solely from \!\pcol@output! to build
% the shipping image of the \ccolpage{} which just has completed in
% \!\@outputbox!.  This macro just invokes its original version \!\@makecol!
% if $\cc_c(\tf)=\infty$ to mean the \colpage{} does not have \sync{}ation
% points.  Otherwise, \!\@makecol! is invoked too but with a special
% \!\def!inition of \!\@textbottom! to put a vertical skip having
% $1/1000\,|fil|$ as its stretch and shrink.  This modification is to
% nullify not only finite stretches (as \!\raggedbottom! does) but also
% finite shrinks possibly inserted just below the last \sync{}ation point to
% move up the first visible item upward a little bit if active.  Therefore,
% \!\flushbottom!  setting is nullified for \colpage{}s having \sync{}ation
% points and a small exceess from the bottom of a \colpage{} cannot be
% absorbed by shrinks but visible at the bottom\footnote{
% 
% That is, the author gives higher priority to the perfect alignment of the
% items following a \sync{}ation point.}.
% 
% Note that the original definition of \!\@textbottom! is saved in
% \Midx{\!\pcol@textbottom!} before the invocation of \!\@makecol! and is
% restored after that\footnote{
% 
% This save/restore cannot be done by a grouping because \!\@makecol! builds
% \!\@outputbox! by local assignments.}.
% 
%    \begin{macrocode}
%% Completing Column-Page

\def\pcol@makecol{\let\pcol@textbottom\@textbottom
  \ifdim\pcol@textfloatsep=\maxdimen\else \ifpcol@lastpage\else
    \def\@textbottom{\vskip\z@\@plus.0001fil\@minus.0001fil}\fi\fi
  \@makecol \let\@textbottom\pcol@textbottom}
%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@combinefloats}
% \changes{v1.0}{2011/10/10}
%	{Introduced for special float handling in a column-page with
%	 synchronization point.}
% 
% The macro \!\pcol@combinefloats! is our own version of \!\@combinefloats!
% which is used in \!\@makecol! and \!\pcol@makenormalcol!.  Since the
% original and our own are made \!\let!-equal by \!\paracol!, our own is
% active throughout the environment.  The customization is twofold for both
% of top and bottom floats.
% 
% For the top floats, we invoke the original \!\@cflt! if
% $\cc_c(\tf)=\infty$ to mean the \colpage{} to be shipped out does not have
% \sync{}ation points, or our own \!\pcol@cflt! which we will discuss
% shortly.  For the bottom floats, we invoke the original \!\@cflb! always
% but, if $\CSIndex{ifpcol@lastpage}=\true$ to mean the \colpage{} is in the
% \lpage, we insert \!\textfloatsep! in
% \!\@outputbox! below the bottom floats so that they are well separated
% from \postenv.  We also insert a vertical skip whose natural height is 0
% but shrink is the natural height of \!\textfloatsep! because the
% \colpage{} can be taller than the height specified by \!\@colht! by up to
% this amount.
% 
% Note that the macro acts exactly same as the original when it is invoked
% from \!\pcol@makenormalcol! because \!\pcol@textfloatsep! and
% \CSIndex{ifpcol@lastpage} has their initial values $\infty$ and $\false$
% given by \!\paracol!.
% 
%    \begin{macrocode}
\def\pcol@combinefloats{%
  \ifx\@toplist\@empty\else
    \ifdim\pcol@textfloatsep=\maxdimen \@cflt \else \pcol@cflt \fi
  \fi
  \ifx\@botlist\@empty\else \@cflb
    \ifpcol@lastpage
      \setbox\@outputbox\vbox{\unvbox\@outputbox \vskip\textfloatsep
        \@tempdima\textfloatsep \vskip\z@\@minus\@tempdima}%
    \fi
  \fi}
%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@cflt}
% \changes{v1.0}{2011/10/10}
%	{Introduced for special float handling in a column-page with
%	 synchronization point.}
% 
% The macro \!\pcol@cflt! is invoked solely from \!\pcol@combinefloats! if
% the \colpage{} for which the macro combines the top floats has
% \sync{}ation points.  The macro has the same structure as \LaTeX's version
% \!\@cflt! but has two modification.  The first one is the floats are
% packed in a \!\vbox! rather than listed in \!\@outputbox! to nullify the
% stretch and shrink of \!\floatsep! to keep the \sync{}ation point from
% moving by them\footnote{
% 
% Maybe unnecessary because of \!\@textbottom! inserted by \!\pcol@makecol!
% but \ldots}.
% 
% The second is that the \!\textfloatsep! is replaced with
% $\!\pcol@textfloatsep!=\cc_c(\tf)$ (definitely finite) which can have a
% value different from \!\textfloatsep! when the float space is enlarged for
% \sync{}ation.  If this enlargement is required, $\cc_c(\tf)$ is biased by
% 10000\,|pt| and thus is assuredly\footnote{
% 
% Though not definitely in theoretical sense.}
% 
% larger than 5000\,|pt|.  If so, the insertion of \!\topfigrule! should be
% inhibited because it has already been inserted by \!\pcol@synccolumn! or
% there are no real floats but we only have the float for main vertical list
% prior to the \sync{}ation point, or {\em\Uidx\mvlfloat} in short.
% 
%    \begin{macrocode}
\def\pcol@cflt{%
  \let\@elt\@comflelt
  \setbox\@tempboxa\vbox{}%
  \@toplist
  \setbox\@outputbox\vbox{
    \boxmaxdepth\maxdepth
    \box\@tempboxa
    \vskip-\floatsep
    \ifdim\pcol@textfloatsep>5000\p@
      \advance\pcol@textfloatsep-\@M\p@
    \else
      \topfigrule
    \fi
    \vskip\pcol@textfloatsep
    \unvbox\@outputbox}%
  \let\@elt\relax
  \xdef\@freelist{\@freelist\@toplist}%
  \global\let\@toplist\@empty}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@opcol}
% \changes{v1.0}{2011/10/10}
%	{Remove unnecessary assignment of \cs{@colht}.}
% \changes{v1.0}{2011/10/10}
%	{Rename \cs{pcol@maxpage} as \cs{pcol@toppage}.}
% 
% The macro \!\pcol@opcol! is invoked from \!\pcol@output! for the ordinary
% completed \colpage{} built by \!\pcol@makecol!, or from the loop creating
% \fcolumn{}s in \!\pcol@output! or \!\pcol@freshpage!.  At first it
% saves the \colpage{} of column $c$ in \!\@outputbox!, which
% \!\pcol@makecol! or \!\@tryfcolumn! just has built for an ordinary or
% \fcolumn{} respectively, in an \!\insert! acquired from \!\@freelist! by
% \!\@next!, and then adds it to the tail of $\S_c=|\pcol@shipped|{\cdot}c$
% 
% \SpecialArrayIndex{c}{\pcol@shipped}
% 
% by \!\@cons!.  Then if $c=0$, we fix the page number of the page $p$
% having the \colpage{} and let $\pp(q)$ represent $\page(p)+(q-p)$ for all
% $q\in[p{+1},\ptop]$ by \!\pcol@setpageno!.  After that, we invoke
% \!\pcol@nextpage! to let $p=p'$ for the next \colpage{} of $c$, where
% $p'=p+1$ usually but can be $p+k+1$ if we have consectutive $k$ \fpage{}s
% from $p+1$.
% 
% Next, we check if the oldest page $\pbase$ is made ready to be shipped out
% by the participation of the completed \colpage{} by \!\pcol@checkshipped!.
% If so, we invoke \!\pcol@outputpage! giving argument 0 to ship out
% $\pbase$ and its successor \fpage{}s.
% 
% Finally we set up the next page $p$ by \!\pcol@startpage! if $p>\ptop$
% meaning it is new one, or by \!\pcol@getcurrpage! otherwise, and
% reinitialize parameters for floats by \!\pcol@floatplacement! before
% returning to the invoker.
% 
%    \begin{macrocode}
\def\pcol@opcol{%
  \@next\@currbox\@freelist{\global\setbox\@currbox\box\@outputbox}\pcol@ovf
  \expandafter\@cons\csname pcol@shipped\number\pcol@currcol\endcsname\@currbox
  \ifnum\pcol@currcol=\z@ \pcol@setpageno \fi
  \pcol@nextpage
  \pcol@checkshipped
  \if@tempswa \pcol@outputpage\z@ \fi
  \ifnum\pcol@page>\pcol@toppage \pcol@startpage
  \else                          \pcol@getcurrpage
  \fi
  \pcol@floatplacement}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@setpageno}
% \begin{macro}{\pcol@setpnoelt}
% \changes{v1.0}{2011/10/10}
%	{Rename \cs{ifpcol@textonly} as \cs{ifpcol@nospan}.}
% 
% The macro \!\pcol@setpageno! is invoked from \!\pcol@opcol! when it
% proceeses the \colpage{} of the first column $c=0$ to fix the page number
% $\page(p)\gets\counter{page}=\!\c@page!$ of the page $p=\!\pcol@page!$
% having the \colpage{}.  It is also invoked from \!\pcol@output@switch!
% when it leaves from the first column to reflect a jump of \counter{page}
% made in the column building.  In both cases, the macro lets $\pp(q)$
% represent $\page'(q)=\page(p)+(q-p)$ for all $q\in[p,\ptop]$.
% 
% Since we possibly have to update $\pp(q)$ such that $q\geq p$, at first we
% temporarily let
% $\Uidx\PPP=(\PP,\pp(\ptop))=\!\pcol@pages!\!\pcol@currpage!$ empty
% after copying its original value into $\mathit{\Pi}'=\!\reserved@a!$.
% Then we scan $\pi'(q)\in\mathit{\Pi}'$ for all $q\in[\pbase,\ptop]$ by
% applying \!\pcol@setpnoelt! to each $\pi'(q)$ to update $\pp(q)$ as
% follows.
% 
% $$
% \pp(q)=\cases{
%   \pi'(q)&		$q<p$\cr
%   \page'(q)&
% 	$q\geq p\;\land\;\pi'(q)\notin[0,255]\;\land\page'(q)<0$\cr
%   \pi'(q)&
% 	$q\geq p\;\land\;\pi'(q)\in[0,255]$\quad
%	(also let $\pp^p(q)=\page'(q)$)\cr
%   \page'(q)+256&
% 	$q\geq p\;\land\;\pi'(q)\notin[0,255]\;\land\page'(q)\geq0$}
% $$
% For the update shown above, the macro \!\pcol@setpnoelt! for $\pi'(q)$ at
% first add $\pp(q-1)$ to the tail of $\PPP$ where $\pp(\pbase-1)$
% is defined as empty.  Then for $q$ such that $q\geq p$, it invokes
% $\!\pcol@setordpage!$ to let $\pp(q)=\page'(q)<0$ or
% $\pp(q)=\page'(q)+256\geq256$ if $\pi'(q)\notin[0,256]$ for an orginary
% page without \spanning, or lets $\pp^p(q)=\page'(q)$
% otherwise.  Note that we let \!\c@page!  have $\page'(q)$, but this
% assignment is temporary and \!\c@page! will regain the value $\page(p)$
% after \!\pcol@setpageno!  finishes.
% 
%    \begin{macrocode}
\def\pcol@setpageno{\begingroup
  \@tempcnta\pcol@page \advance\@tempcnta-\pcol@basepage
  \edef\reserved@a{\pcol@pages\pcol@currpage}%
  \global\let\pcol@pages\@empty \global\let\pcol@currpage\@empty
  \let\@elt\pcol@setpnoelt \reserved@a
  \endgroup}
\def\pcol@setpnoelt#1{%
  {\let\@elt\relax \xdef\pcol@pages{\pcol@pages\pcol@currpage}}%
  \pcol@nospantrue
  \ifnum#1<\z@         \gdef\pcol@currpage{\@elt{#1}}%
  \else\ifnum#1>\@cclv \gdef\pcol@currpage{\@elt{#1}}%
  \else                \gdef\pcol@currpage{\@elt#1}\pcol@nospanfalse
  \fi\fi
  \ifnum\@tempcnta>\z@\else
    \ifpcol@nospan \pcol@setordpage
    \else          \global\count#1\c@page
    \fi
    \advance\c@page\@ne
  \fi
  \advance\@tempcnta\m@ne}
%    \end{macrocode}
% \end{macro}\end{macro}
% 
% \begin{macro}{\pcol@setordpage}
% \changes{v1.0}{2011/10/10}
%	{Renamed from \cs{pcol@settextpage}.}
% 
% The macro \!\pcol@setordpage! is invoked from \!\pcol@setpnoelt! and
% \!\pcol@startpage! to let $\pp(q)$ for the ordinary page $q$ without
% \spanning{} as follows.
% $$
% \pp(q)=\cases{\!\c@page!&	$\!\c@page!<0$\cr
% 		\!\c@page!+256&	$\!\c@page!\geq0$}
% $$
% In the invocatoin from \!\pcol@setpnoelt!, $q\in[p,\ptop]$ and
% $\!\c@page!=\page(p)+(q-p)$, while $q=p=\ptop$ and $\!\c@page!=\page(p)$
% in the invocation from \!\pcol@startpage!.
% 
%    \begin{macrocode}
\def\pcol@setordpage{\begingroup
  \@tempcnta\c@page
  \ifnum\@tempcnta<\z@\else \advance\@tempcnta\@cclvi \fi
  \let\@elt\relax \xdef\pcol@currpage{\@elt{\number\@tempcnta}}
  \endgroup}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@nextpage}
% \begin{macro}{\pcol@nextpelt}
% The macro \!\pcol@nextpage! is invoked solely in \!\pcol@opcol! to let
% $p$ be $p+k+1$ where $k$ is the number of \fpage{}s directly following
% $p$.  For this update, the macro scans $\pp(q)\in\PP$ for all
% $q\In\pbase\ptop$ applying \!\pcol@nextpelt! to $\pp(q)$, to perform
% the following where $f=\CSIndex{if@tempswa}$ being $\true$ at initial, to
% let $p\gets p+k$, and then increments $p$ to have $p+k+1$.
% $$
% \<p,f\>\gets\cases{
% 	\<p,f\>&	$q\leq p$\cr
% 	\<p{+}1,f\>&	$q>p\;\land\;f\;\land\;\pp(q)\in[0,255]\;\land\;
%			\pp^h(q)<0$\cr
%	\<p,\false\>&	otherwise}
% $$
% 
%    \begin{macrocode}
\def\pcol@nextpage{\begingroup
  \@tempcnta\pcol@page \advance\@tempcnta-\pcol@basepage
  \@tempswatrue
  \let\@elt\pcol@nextpelt \pcol@pages\pcol@currpage
  \global\advance\pcol@page\@ne
  \endgroup}
\def\pcol@nextpelt#1{%
  \ifnum\@tempcnta<\z@
    \ifnum#1<\z@ \@tempswafalse
    \else\ifnum#1>\@cclv \@tempswafalse
    \else\ifdim\dimen#1<\z@
      \if@tempswa \global\advance\pcol@page\@ne \fi
    \else \@tempswafalse
    \fi\fi\fi
  \fi
  \advance\@tempcnta\m@ne}

%    \end{macrocode}
% \end{macro}\end{macro}
% 
% \begin{macro}{\pcol@checkshipped}
% The macro \!\pcol@checkshipped! is invoked solely in \!\pcol@opcol! to let
% \CSIndex{if@tempswa} be true iff $S_c=|\pcol@shipped|{\cdot}c\neq()$
% 
% \SpecialArrayIndex{c}{\pcol@shipped}
% 
% for all $c\In0\C$ to mean the oldest page $\pbase$ is ready to be shipped
% out.
% 
%    \begin{macrocode}
\def\pcol@checkshipped{\@tempswatrue
  \@tempcnta\z@ \@whilenum\@tempcnta<\pcol@ncol\do{%
    \expandafter\ifx\csname pcol@shipped\number\@tempcnta\endcsname\@empty
      \@tempswafalse \fi
   \advance\@tempcnta\@ne}}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@getcurrpage}
% \begin{macro}{\pcol@getpelt}
% \begin{macro}{\pcol@getpinfo}
% \changes{v1.0}{2011/10/10}
%	{Rename \cs{ifpcol@textonly} as \cs{ifpcol@nospan}.}
% 
% \begin{macro}{\pcol@getcurrpinfo}
% The macro \!\pcol@getcurrpage! is ivoked in \!\pcol@opcol!,
% \!\pcol@restartcolumn!, \!\pcol@flushcolumn! and \!\pcol@freshpage! to let
% \!\c@page!, \!\@colht!, \!\topskip! and \CSIndex{ifpcol@nospan} be those
% represented in $\pp(p)\in\PPP=(\PP,\pp(\ptop))$ where
% $\pp(\ptop)=\!\pcol@currpage!$.  To do that, the macro scans all
% $\pp(q)\in\PPP$ applying \!\pcol@getpelt!  to $\pp(q)$ to invoke
% $\!\pcol@getpinfo!\arg{\pi}\arg{pg}\arg{ch}\arg{ts}$ with the following
% arguments for \!\global! assignments, if $q=p$.
% $$
% \arg{\pi}=\pp(q)\quad\arg{pg}=\!\global!\!\c@page!\quad
% \arg{ch}=\!\global!\!\@colht!\quad\arg{ts}=\!\global!\!\topskip!
% $$
% Then the macro \!\pcol@getpinfo! do the following assighments.
% 
% \begin{eqnarray*}
% &&\<\arg{pg},\arg{ch},\arg{ts},\CSIndex{ifpcol@nospan}\>=\\
% &&\qquad\qquad\left\{\begin{array}{lllll}
%	\<\pp(q),&\!\textheight!,&\!\pcol@topskip!,&\true\>&\quad\pp(q)<0\\
%	\<\pp^p(q),&\pp^h(q),&\pp^t(q),&\false\>&\quad0\leq\pp(q)<256\\
%	\<\pp(q){-}256,&\!\textheight!,&\!\pcol@topskip!,&\true\>&
% 		\quad\pp(q)\geq256\end{array}\right.
% \end{eqnarray*}
% 
% The other macro $\!\pcol@getcurrpinfo!\arg{cs}\arg{pg}\arg{ch}\arg{ts}$ is
% invoked in \!\pcol@startpage!, \!\pcol@sync! and \!\pcol@makeflushedpage!
% do the similar assignments using \!\pcol@getpinfo!, but it is not for
% $\pp(p)$ but for $\pp(\ptop)$ which is assigned to $\arg{cs}$.  The macro
% \!\pcol@getpinfo! also has a direct invoker \!\pcol@outputelt!.
% 
%    \begin{macrocode}
\def\pcol@getcurrpage{\begingroup
  \@tempcnta\pcol@page \advance\@tempcnta-\pcol@basepage
  \let\@elt\pcol@getpelt \pcol@pages\pcol@currpage
  \endgroup}
\def\pcol@getpelt#1{%
  \ifnum\@tempcnta=\z@
    \pcol@getpinfo{#1}{\global\c@page}{\global\@colht}{\global\topskip}\fi
  \advance\@tempcnta\m@ne}
\def\pcol@getpinfo#1#2#3#4{\count@#1\relax \pcol@nospantrue
  \ifnum\count@>\@cclv
    \advance\count@-\@cclvi #2\count@ #3\textheight #4\pcol@topskip
  \else\ifnum\count@<\z@
    #2\count@ #3\textheight #4\pcol@topskip
  \else #2\count\count@  #3\dimen\count@ #4\skip\count@ \pcol@nospanfalse
  \fi\fi}
\def\pcol@getcurrpinfo#1{%
  \edef#1{\expandafter\@cdr\pcol@currpage\@nil}%
  \pcol@getpinfo#1}

%    \end{macrocode}
% \end{macro}\end{macro}\end{macro}\end{macro}
% 
% 
% 
% \section{Starting New Page}
% \label{sec:imp-startpage}
% 
% \begin{macro}{\pcol@startpage}
% \changes{v1.0}{2011/10/10}
%	{Add assignment of \cs{pcol@firstprevdepth} to be \cs{relax}.}
% \changes{v1.0}{2011/10/10}
%	{Rename \cs{pcol@maxpage} as \cs{pcol@toppage}.}
% \changes{v1.0}{2011/10/10}
%	{Rename \cs{pcol@settextpage} as \cs{pcol@setordpage}.}
% 
% The macro \!\pcol@startpage! is invoked from \!\pcol@opcol! with
% $\!\pcol@currpage!=\pp(p{-}1)$ to start a new page $p=\!\pcol@page!$, or
% from \!\pcol@output@start! or \!\pcol@freshpage! with
% $\!\pcol@currpage!=|{}|$ and $\!\c@page!=\page(p)$ to start a new page
% $p=0$.
% 
% First, we let $\!\pcol@firstprevdepth!=\!\relax!$ to mean we have (had)
% left from the first page of \env{paracol} environment so that
% \!\pcol@output@end! will be informed of that.  Next we let $\ptop=p$ and
% then, if invoked from \!\pcol@opcol!, lets $\!\c@page!=\page(p{-}1)+1$
% invoking \!\pcol@getcurrpinfo! to have $\page(p{-}1)$ in \!\c@page! from
% $\pp(p{-}1)$ and \!\stepcounter! to increment it, and
% $\PP\gets\PPP=(\PP,\pp(p{-}1))$.  Then we let $\!\@colht!=\!\textheight!$
% as the base value without \spanning, and $\!\topskip!=\!\pcol@topskip!$
% because the new page is the second or succeeding one built in
% \env{paracol} environment.
% 
%    \begin{macrocode}
%% Starting New Page

\def\pcol@startpage{%
  \global\let\pcol@firstprevdepth\relax
  \global\pcol@toppage\pcol@page
  \ifx\pcol@currpage\@empty\else
    \pcol@getcurrpinfo\@currbox{\global\c@page}\@tempdima\@tempskipa
    \stepcounter{page}%
    \xdef\pcol@pages{\pcol@pages\pcol@currpage}%
  \fi
  \global\@colht\textheight
  \global\topskip\pcol@topskip
%    \end{macrocode}
% 
% Then, we build \fpage{}s if any as follows.  First we invoke
% \!\@dblfloatplacement! to reinitialize the parameters for double-column
% (multiple-column) float placement.  Then we repeat \!\@tryfcolumn! giving
% it \!\@dbldeferlist! having double-column floats not contributed to
% previous pages yet, while $\CSIndex{if@fcolmade}=\true$ meaning it builds
% \fpage{}s in \!\@outputbox!.  For each \fpage{}, we acquire an \!\insert!
% from \!\@freelist! by \!\@next! to let $\pp(p)=\pp(\ptop)$ have the
% followings to represent the \fpage{}.
% $$
% \pp^b(p)=\!\@outputbox!\quad
% \pp^p(p)=\!\c@page!\quad
% \pp^h(p)=-\!\maxdimen!\quad
% \pp^t(p)=\!\pcol@topskip!
% $$
% We also increment $p$ and $\ptop$, and also \!\c@page! by \!\stepcounter!,
% to let them have the values for the page following the \fpage{}s.
% 
%    \begin{macrocode}
  \@dblfloatplacement
  \@tryfcolumn\@dbldeferlist
  \@whilesw\if@fcolmade\fi{%
    \@next\@currbox\@freelist{%
      \global\setbox\@currbox\box\@outputbox}\pcol@ovf
    \global\count\@currbox\c@page
    \global\dimen\@currbox-\maxdimen
    \global\skip\@currbox\pcol@topskip
    \@cons\pcol@pages\@currbox
    \stepcounter{page}%
    \global\advance\pcol@page\@ne \global\pcol@toppage\pcol@page
    \@tryfcolumn\@dbldeferlist}%
%    \end{macrocode}
% 
% Next, we copy \!\@dbldeferlist! containing double-column floats which
% could not be included in \fpage{}s to \!\reserved@b!, clear the list, and
% then scan the copied list by applying \!\@sdblcolelt! to each list
% element to invoke \!\@addtodblcol! for adding the element to \!\@dbltoplist!
% or keeping it in \!\@dbldeferlist!, as \LaTeX's \!\@startdblcolumn!
% does.  If this scan results in empty \!\@dbltoplist! to mean the new page
% does not have any \spanning, we invoke \!\pcol@setordpage! so that
% $\pp(\ptop)$ reprsents a page without \spanning.
% 
%    \begin{macrocode}
  \begingroup
    \let\reserved@b\@dbldeferlist
    \global\let\@dbldeferlist\@empty
    \let\@elt\@sdblcolelt
    \reserved@b
  \endgroup
  \ifx\@dbltoplist\@empty
    \pcol@setordpage
%    \end{macrocode}
% 
% Otherwise, i.e., \!\@dbltoplist! is not empty, we scan all elements in it
% by letting \!\@comdblflelt! to have all double-floats in \!\@tempboxa!.
% Then, after returning all elements to \!\@freelist!, we acquire a
% \!\insert! from \!\@freelist! to be $\pp(\ptop)$ by \!\@next! and store the
% contents of \!\@tempboxa! in $\pp^b(\ptop)$ after removing the
% last vertical skip \!\dblfloatsep! and then adding \!\dblfigrule! and the
% vertical skip \!\dbltextfloatsep!.  The other element of $\pp(\ptop)$ is
% set as follows to represent the page with \spanning{} which make the height
% of each column \!\@colht! shrunk from its initial value \!\textheight!
% by the series of \!\@addtodblcol!.
% $$
% \pp^p(\ptop)=\!\c@page!=\page(\ptop)\quad
% \pp^h(\ptop)=\!\@colht!\quad
% \pp^t(\ptop)=\!\pcol@topskip!
% $$
% 
%    \begin{macrocode}
  \else
    \setbox\@tempboxa\vbox{}%
    \begingroup
      \let\@elt\@comdblflelt
      \@dbltoplist
      \let\@elt\relax
      \xdef\@freelist{\@freelist\@dbltoplist}%
      \global\let\@dbltoplist\@empty
      \@next\@currbox\@freelist{%
        \global\setbox\@currbox\vbox{%
          \unvbox\@tempboxa \vskip-\dblfloatsep \dblfigrule
          \vskip\dbltextfloatsep}}%
        \pcol@ovf
      \global\count\@currbox\c@page
      \global\dimen\@currbox\@colht
      \global\skip\@currbox\pcol@topskip
      \xdef\pcol@currpage{\@elt\@currbox}%
    \endgroup
  \fi
}

%    \end{macrocode}
% \end{macro}
% 
% 
% 
% \section{Shipping Page Out}
% \label{sec:imp-outputpage}
% 
% \begin{macro}{\pcol@outputpage}
% \changes{v1.0}{2011/10/10}
%	{Rename \cs{ifpcol@stopoutput} as \cs{ifpcol@outputflt}.}
% 
% The macro \!\pcol@outputpage! is invoked from \!\pcol@opcol! with argument
% $\arg{all}=0$ to ship out the page $\pbase$ and \fpage{}s following it if
% any, or \!\pcol@sync! with $\arg{all}=1$ to ship out all pages in $\PP$.
% It copies $\PP=\!\pcol@pages!$ into $\mathit{\Pi}'=\!\reserved@b!$ and
% clear $\PP$ once to remove pages shipped out from it.  Then, after
% initializing $f_o=\CSIndex{if@tempswa}=\true$ to ship out (the first)
% ordinary page and $f_f=\CSIndex{ifpcol@outputflt}=\true$ to ship out
% \fpage{} (following the first page), scan all $\pp(q)\in\mathit{\Pi}'$
% applying $\!\pcol@outputelt!\arg{all}$ to $\pp(q)$ to ship it out or keep
% it in $\PP$.
% 
%    \begin{macrocode}
%% Shipping Page Out

\def\pcol@outputpage#1{\begingroup
  \def\@elt{\pcol@outputelt#1}\@tempswatrue \pcol@outputflttrue
  \let\reserved@b\pcol@pages \gdef\pcol@pages{}%
  \reserved@b
  \endgroup}
%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@outputelt}
% The macro $\!\pcol@outputelt!\arg{all}\<\pp(q)\>$ ships out the ordinary
% or \fpage{} $q$ if $f_o=\true$ or $f_f=\true$ respectively.  After
% initializing \!\@outputbox! to be \!\voidb@x!, we retrive the page $q$'s
% information by \!\pcol@getpinfo! to have $\page(q)$ in \!\c@page! locally,
% \!\textheight! or $\pp^h(q)$ in $h=\!\@tempdima!$, and
% $f_{\it ns}=\CSIndex{ifpcol@nospan}=(\pp(q)\notin[0,255])$.
% 
%    \begin{macrocode}
\def\pcol@outputelt#1#2{%
  \setbox\@outputbox\box\voidb@x
  \def\@currbox{#2}%
  \pcol@getpinfo\@currbox\c@page\@tempdima\@tempskipa
%    \end{macrocode}
% 
% Then, we do one of the follolwings according to $h$ and $f_o$.
% 
% \begin{itemize}
% \item $h<0$\\
% It means $q$ is a \fpage{}.  If $f_f=\true$, we let \!\@outputbox! have
% $\pp^b(q)$ to ship it out and return $\!\insert!{\cdot}\pp(q)$ to
% \!\@freelist! by \!\@cons! because it is no longer necessary.  Otherwise,
% we return $\pp(q)$ back to $\PP$.
% \end{itemize}
% 
% \changes{v1.0}{2011/10/10}
%	{Rename \cs{ifpcol@stopoutput} as \cs{ifpcol@outputflt}.}
% 
%    \begin{macrocode}
  \ifdim\@tempdima<\z@
    \ifpcol@outputflt
      \setbox\@outputbox\box\@currbox
      \@cons\@freelist\@currbox
    \else
      \@cons\pcol@pages\@currbox
    \fi
%    \end{macrocode}
% 
% \begin{itemize}
% \item $h\geq0\;\land\;f_o=\true$\\
% It means $q$ is a non-\fpage{} to be shipped out.  If $\arg{all}=0$, we
% let $f_o=\false$ to keep succeeding non-\fpage{}s from being shipped out.
% Then we put materials to be shipped out in \!\@outputbox! whose height is
% \!\textheight! as follows.  First, if $f_{\it ns}=\false$ to mean
% $\pp(q)$ has \spanning{} in $\pp^b(q)$, they are put in the box by
% \!\unvbox! and $\!\insert!{\cdot}\pp(q)$ is returned to \!\@freelist! by
% \!\@cons!.  Then we put a \!\hbox! of \!\textwidth! wide having \!\hbox!es
% of \!\columnwidth! wide containing $\sigma_c$ followed by \!\hss! for all
% $c\In0\C$, where $\sigma_c=\!\box!{\cdot}s_c(q)$ being the first element
% removed from $\S_c$ by \!\@next! and then returned to \!\@freelist! by
% \!\@cons! if it is not empty, or \!\voidb@x!  otherwise.  We sepearate
% \!\hbox!es of $\sigma_c$ by \!\hfil!  by making each \!\hbox!  preceded by
% \!\pcol@hfil!
% 
% \SpecialMainIndex{\pcol@hfil}
% 
% being \!\relax! for the first one and \!\hfil! for others.
% \end{itemize}
% 
% \changes{v1.0}{2011/10/10}
%	{Rename \cs{ifpcol@textonly} as \cs{ifpcol@nospan}.}
% 
%    \begin{macrocode}
  \else\if@tempswa
    \ifnum#1=\z@ \@tempswafalse \fi
    \setbox\@outputbox\vbox to\textheight{%
      \ifpcol@nospan\else
        \@cons\@freelist\@currbox
        \unvbox\@currbox
      \fi
      \hb@xt@\textwidth{%
        \let\pcol@hfil\relax
        \@tempcnta\z@ \@whilenum\@tempcnta<\pcol@ncol\do{%
          \expandafter\@next\expandafter\@currbox
            \csname pcol@shipped\number\@tempcnta\endcsname
            \relax{\let\@currbox\voidb@x}%
          \ifvoid\@currbox\else \@cons\@freelist\@currbox \fi
          \pcol@hfil \hb@xt@\columnwidth{\box\@currbox\hss}%
          \let\pcol@hfil\hfil
         \advance\@tempcnta\@ne}}}%
%    \end{macrocode}
% 
% \begin{itemize}
% \item $h\geq0\;\land\;f_o=\false$\\
% It means $q$ is a non-\fpage{} to be kept.  Therefore, we let
% $f_f=\false$ to keep \fpage{}s following it from being shipped out.  Then
% we return $\pp(q)$ to $\PP$ by \!\@cons!.  Note that if $f_{\it ns}=\true$
% to mean $\pp(q)\notin[0,255]$ for a page without \spanning, we have to
% surround $\pp(q)$ giving to \!\@cons! by |{| and |}| because it is a
% decimal number rather than a \!\chardef! token for an \!\insert! with
% \spanning.
% \end{itemize}
% 
%    \begin{macrocode}
  \else
    \pcol@outputfltfalse
    \ifpcol@nospan
      \@cons\pcol@pages{{\@currbox}}
    \else
      \@cons\pcol@pages\@currbox
    \fi
  \fi\fi
%    \end{macrocode}
% 
% Finally, if $\!\@outputbox!\neq\!\voidb@x!$ to mean $\pp(q)$ is to be
% shipped out, we invoke \!\@outputpage! to do it and increment $\pbase$ to
% let it has $q+1$.  Note that since we have let $\!\c@page!=\page(q)$, the
% direct and indirect references to it in \!\@outputpage! are correctly done.
% Also note that the \!\global! increment of it by \!\stepcounter! in
% \!\@outputpage! will be overriden by the \!\global! assignment to it done
% by \!\pcol@startpage! or \!\pcol@getcurrpage! invoked from \!\pcol@opcol!
% if $\arg{all}=0$, or by \!\pcol@getcurrpinfo! invoked from \!\pcol@sync!
% otherwise.
% 
%    \begin{macrocode}
  \ifvoid\@outputbox\else
    \@outputpage \global\advance\pcol@basepage\@ne
  \fi}

%    \end{macrocode}
% \end{macro}
% 
% 
% 
% \section{Starting New Column-Page}
% \label{sec:imp-startcolumn}
% 
% \begin{macro}{\pcol@startcolumn}
% \begin{macro}{\pcol@trynextcolumn}
% The macro \!\pcol@startcolumn! is invoked from \!\pcol@output! and
% \!\pcol@freshpage! to start a new \colpage.  This macro has the exactly
% same functionality as \LaTeX's \!\@startcolumn!, but \CSIndex{else} part of
% \CSIndex{if@fcolmade} construct is enclosed in the macro
% \!\pcol@trynextcolumn!  which is also invoked in \!\pcol@flushcolumn!.
% That is, the only reason why we have our own version of \!\@startcolumn!
% is this additional use of the \CSIndex{else} part.
% 
%    \begin{macrocode}
%% Starting New Column Page

\def\pcol@startcolumn{%
  \global\@colroom\@colht
  \@tryfcolumn\@deferlist
  \if@fcolmade\else \pcol@trynextcolumn \fi}
\def\pcol@trynextcolumn{\begingroup
  \let\reserved@b\@deferlist
  \global\let\@deferlist\@empty
  \let\@elt\@scolelt
  \reserved@b
  \endgroup}

%    \end{macrocode}
% \end{macro}\end{macro}
% 
% 
% 
% \section{Special Output Routines}
% \label{sec:imp-sout}
% 
% \subsection{Dispatcher}
% \label{sec:imp-sout-disp}
% 
% \begin{macro}{\pcol@op@start}
% \begin{macro}{\pcol@op@switch}
% \begin{macro}{\pcol@op@flush}
% \begin{macro}{\pcol@op@clear}
% \begin{macro}{\pcol@op@end}
% The macros $|\pcol@op@|{\cdot}f$ where $f\in
% F=\{|start|,|switch|,|flush|,|clear|,|end|\}$ has our own
% \!\outputpenalty! code less than $-10000$ to invoke the corresponding
% macros $|\pcol@output@|{\cdot}f$.  The code macros are given to
% \!\pcol@invokeoutput! as its argument by \!\paracol! ($f=|start|$),
% \!\pcol@switchcol! ($f=|switch|$), \!\pcol@com@flushpage! ($f=|flush|$),
% \!\pcol@com@clearpage! ($f=|clear|$) and \!\endparacol! ($f=|end|$) to set
% one of them into \!\outputpenalty!, so that the other user
% \!\pcol@specialoutput! examines which special function is invoked.
% 
% \SpecialIndex{\pcol@output@start}
% \SpecialIndex{\pcol@output@switch}
% \SpecialIndex{\pcol@output@flush}
% \SpecialIndex{\pcol@output@clear}
% \SpecialIndex{\pcol@output@end}
% 
%    \begin{macrocode}
%% Special Output Routines: Dispatcher

\def\pcol@op@start{-10010}
\def\pcol@op@switch{-10011}
\def\pcol@op@flush{-10012}
\def\pcol@op@clear{-10013}
\def\pcol@op@end{-10014}
%    \end{macrocode}
% \end{macro}\end{macro}\end{macro}\end{macro}\end{macro}
% 
% \begin{macro}{\pcol@specialoutput}
% \changes{v1.0}{2011/10/10}
%	{Remove unnecessary \cs{pcol@latex@specialoutput}.}
% 
% The macro \!\pcol@specialoutput! is invoked solely in \!\pcol@output! to
% invoke our own or \LaTeX's special output routine.  It examines if
% $\!\outputpenalty!\in\{|pcol@op@|{\cdot}f\vert f\in F\}$.  If so, before
% invoking $|\pcol@output@|{\cdot}f$, we rebuild \!\@holdpg! removing
% \!\lastbox! and the last vertical skip as done in \LaTeX's
% \!\@specialoutput!.  We also let $\!\outputpenalty!=-10000$\footnote{
% 
% It can be any value larger than -10004.}
% 
% so that \!\vsize! is correctly set to \!\@colroom! in the second half of
% \!\pcol@output! after this macro finishes.
% 
% Otherwise, i.e., if $\!\outputpenalty!\notin\{|pcol@op@|{\cdot}f\vert f\in
% F\}$, we simply invokes \LaTeX's \!\@specialoutput!.
% 
%    \begin{macrocode}
\def\pcol@specialoutput{%
  \ifnum\outputpenalty=\pcol@op@start\relax
    \let\reserved@a\pcol@output@start
  \else\ifnum\outputpenalty=\pcol@op@switch\relax
    \let\reserved@a\pcol@output@switch
  \else\ifnum\outputpenalty=\pcol@op@flush\relax
    \let\reserved@a\pcol@output@flush
  \else\ifnum\outputpenalty=\pcol@op@clear\relax
    \let\reserved@a\pcol@output@clear
  \else\ifnum\outputpenalty=\pcol@op@end\relax
    \let\reserved@a\pcol@output@end
  \else \let\reserved@a\@specialoutput
  \fi\fi\fi\fi\fi
  \ifx\reserved@a\@specialoutput\else
    \global\setbox\@holdpg\vbox{\unvbox\@holdpg \unvbox\@cclv
      \setbox\@tempboxa\lastbox \unskip}%
    \outputpenalty-\@M
  \fi
  \reserved@a}

%    \end{macrocode}
% \end{macro}
% 
% 
% 
% \subsection{Building Starting Page}
% \label{sec:imp-sout-start}
% 
% \begin{macro}{\pcol@output@start}
% \changes{v1.0}{2011/10/10}
%	{Change the order of operations.}
% \changes{v1.0}{2011/10/10}
%	{Rename \cs{pcol@maxpage} as \cs{pcol@toppage}.}
% \changes{v1.0}{2011/10/10}
%	{Add special operation in case of too small room for column-pages.}
% 
% The macro \!\pcol@output@start! is invoked solely from
% \!\pcol@specialoutput! to process the special \!\output! request made in
% \!\paracol! and to build the {\em\Uidx\spage} from which parallel columns
% start.  First we invoke \!\pcol@makenormalcol! to let \!\@outputbox! have
% the stuff preceding \beginparacol{}, or {\em\Uidx\preenv} in short, in the
% \spage{} as its \spanning.  Then we shrink \!\@colht! by the sum of the
% height $h$ and depth $d$ of the \spanning.  Next we let $p=\pbase=\ptop=0$
% and $\PP=()$ because we have nothing for $q<\ptop=0$.  We also move
% \!\@deferlist! to \!\@dbldeferlist! and then let \!\@deferlist! be empty
% because all single-column dererred floats become multi-column.
% 
% Then we examine if $\!\@colht!<1.5\times\!\baselineskip!$ to mean
% \!\pcol@output! would force a page break with warning.  If so, we ship out
% the \preenv{} by \!\@outputpage! to avoid the break and warning, and
% invoke \!\pcol@startpage! for the \spage{} $\ptop=0$ letting $\pp(0)$ be
% empty so that the macro will not refer to it.  We also let \!\topskip! be
% the value at \beginparacol, i.e., \!\pcol@topskip! because the first item
% of each column will start from the top of the \spage.
% 
% Otherwise, the \spanning{} are moved in $\pp^b(0)$ which is acquired from
% \!\@freelist! by \!\@next!, and $\pp^p(0)$ and $\pp^h(0)$ are let be
% \!\c@page! and \!\@colht! respectively for \spage.  As for $\pp^t(0)$, we
% let it be \!\topskip! if $h=d=0$ assuming that the page does not have any
% \spanning{} to typeset \colpage{}s from the top of the page.  Otherwise,
% i.e., either $h\neq0$ or $d\neq0$, $\pp^t(0)$ and \!\topskip! are let be 0
% to inhibit the ordinary \!\topskip! insertion.
% 
% Then for the both cases, we initialize \!\@colroom! to be \!\@colht!, and
% invoke \!\pcol@floatplacement! to reinitialize the parameters of
% single-column float placement.
% 
%    \begin{macrocode}
%% Special Output Routines: Building First Page

\def\pcol@output@start{%
  \pcol@makenormalcol
  \global\advance\@colht-\ht\@outputbox
  \global\advance\@colht-\dp\@outputbox
  \global\pcol@page\z@ \global\pcol@toppage\z@ \global\pcol@basepage\z@
  \global\let\pcol@pages\@empty
  \global\let\@dbldeferlist\@deferlist \global\let\@deferlist\@empty
  \ifdim\@colht<1.5\baselineskip
    \@outputpage
    \global\let\pcol@currpage\@empty \pcol@startpage
    \global\topskip\pcol@topskip 
  \else
    \@next\@currbox\@freelist{\global\setbox\@currbox\box\@outputbox}\pcol@ovf
    \global\count\@currbox\c@page \global\dimen\@currbox\@colht
    \@tempskipa\z@
    \ifdim\ht\@currbox=\z@ \ifdim\dp\@currbox=\z@
      \@tempskipa\topskip
    \fi\fi
    \global\skip\@currbox\@tempskipa \global\topskip\@tempskipa
    \xdef\pcol@currpage{\@elt\@currbox}%
  \fi
  \global\@colroom\@colht
  \pcol@floatplacement
%    \end{macrocode}
% 
% Then for all columns $c\In0\C$ we do the followings to build $\cc_c$.
% First, if we have let $\!\topskip!=0$ with the \preenv,
% we let $\cc_c(\vb^b)$ have an invisible \!\hrule! whose
% height and depth are 0 as the very first vertical item of the \colpage.
% When we visit the column $c$ for the first time afterward, we will
% \!\unvbox! the box to let \TeX's page builder have $\!\topskip!=0$ and the
% invisible rule.  Then the first vertical item of the \colpage{} is added
% but it is recognized as non-first by \TeX's page builder and thus it
% inserts \!\baselineskip! referring to \!\prevdepth! as the depth of the
% last item.  The important issue is that the \!\prevdepth! to be referred
% is assured having its value at \beginparacol, which is usually the depth
% of the last item of \spanning, by the following mechanism: (1)
% \!\pcol@invokeoutput!  invoked in \!\paracol! saves \!\prevdepth! in
% \!\pcol@prevdepth! before the \!\output! request for
% \!\pcol@output@start!; (2) \!\pcol@prevdepth! is saved in $\cc_c(\pd)$ by
% \!\pcol@setcurrcolnf!  invoked from \!\pcol@output@start! as discussed
% afterward; (3) when the column $c$ is visited for the first time, the
% special output routine \!\pcol@output@start! itself ($c=0$) or
% \!\pcol@output@switch! ($c>0$) restores \!\pcol@prevdepth! from
% $\cc_c(\pd)$ by \!\pcol@getcurrcol!; (4) \!\pcol@invokeoutput!  which made
% the \!\output! request for (3) lets \!\prevdepth! have the value of
% \!\pcol@prevdepth! after the request.  Therefore, the baseline progress
% from the last line of the \spanning{} to the first line of each
% \colpage{} should be very natural as we see in the third and fourth lines
% of \secref{sec:man-close}.
% 
% Then we invoke \!\pcol@setcurrcolnf! to save the following values for
% $\cc_c(e)$ ($e\neq\vb$); $\cc_c(\ft)=\!\voidb@x!$ because $c$ does not
% have footnotes;  $\cc_c(\pd)=\!\prevdepth!$ as discussed above;
% $\cc_c(\tl)=\cc_c(\ml)=\cc_c(\bl)=()$ because \!\pcol@makenormalcol! and
% \!\@combinefloats! invoked from it emptied them;  $\cc_c(\dl)=()$ as
% discussed above;  $\cc_c(\fh)=\cc_c(\mb)=0$ as initialized by
% \!\pcol@floatplacement!;  $\cc_c(\tn)=\!\c@topnumber!$,
% $\cc_c(\bn)=\!\c@botnumber!$ and $\cc_c(\tn)=\!\c@totalnumber!$ as
% initialized by \!\@floatplacement! invoked from \!\pcol@floatplacement!;
% $\cc_c(\tr)=\!\topfraction!\times\!\@colht!$ and
% $\cc_c(\br)=\!\bottomfraction!\times\!\@colht!$ as initialized by
% \!\@floatplacement!; $\cc_c(\sw)$ is defined by \CSIndex{if@nobreak} and
% \CSIndex{if@afterindent} at the time of \beginparacol; and
% $\cc_c(\ep)=\!\everypar!$ at the time of \beginparacol.  We also let
% $\cc_c(\vb^p)=0$ because $p=0$ and $\cc_c(\vb^r)=\!\@colroom!$ defined
% above.  In addition, we let $\S_c=\phi$ because we don't have any
% \colpage{} having been completed.
% 
% \changes{v1.0}{2011/10/10}
%	{Add clearing of $S_c$.}
% 
%    \begin{macrocode}
  \pcol@currcol\z@ \@whilenum\pcol@currcol<\pcol@ncol\do{%
    \@next\@currbox\@freelist{\global\setbox\@currbox\vbox{%
      \ifdim\topskip=\z@ \hrule\@height\z@\@width\z@
      \fi}}
      \pcol@ovf
    \pcol@setcurrcolnf
    \global\count\@currbox\z@
    \global\dimen\@currbox\@colroom
    \expandafter\gdef\csname pcol@shipped\number\pcol@currcol\endcsname{}%
   \advance\pcol@currcol\@ne}%
%    \end{macrocode}
%
% Finally, we let $c=\!\pcol@currcol!=0$ for the first column, regain the
% parameters in $\cc_0$, and put $\cc_0(\vb^b)$ to the main
% vertical list by \!\unvbox! returning $\cc_0(\vb)$ to \!\@freelist! by
% \!\@cons! because it has become useless so far.
% 
%    \begin{macrocode}
  \global\pcol@currcol\z@
  \pcol@getcurrcol
  \@cons\@freelist\@currbox
  \unvbox\@currbox}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@makenormalcol}
% The macro \!\pcol@makenormalcol! is invoked solely from
% \!\pcol@output@start! to let \!\@output~box! have the \preenv{} as the
% \spanning{} of the \spage.  The macro is very similar to the first half of
% \!\@makecol! but \!\@cclv! in it is replaced with \!\@holdpg! because the
% stuff have been stored in \!\@holdpg! by \!\pcol@specialoutput!.  Note
% that bottom floats and footnotes are put in \!\@outputbox! and thus they
% will not appear at the bottom of the page but above the \colpage{}s in the
% page\footnote{
% 
% We could put them at the bottom by keeping them somewhere and insert them
% in \!\pcol@outputpage!, but it will cause another problem that the numbers
% of the figures and footnotes are smaller than those in \colpage{}s which
% are above them.}.
% 
%    \begin{macrocode}
\def\pcol@makenormalcol{%
  \ifvoid\footins \setbox\@outputbox\box\@holdpg
  \else
    \setbox\@outputbox\vbox{
      \boxmaxdepth\@maxdepth
      \unvbox\@holdpg
      \vskip\skip\footins
      \color@begingroup
        \normalcolor
        \footnoterule
        \unvbox\footins
      \color@endgroup}%
   \fi
  \let\@elt\relax
  \xdef\@freelist{\@freelist\@midlist}%
  \global\let\@midlist\@empty
  \@combinefloats}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@floatplacement}
% \changes{v1.0}{2011/10/10}
%	{Add initialization of \cs{pcol@textfloatsep}.}
% 
% The macro \!\pcol@floatplacement! is invoked from \!\pcol@opcol!,
% \!\pcol@output@start!, \!\pcol@flushcolumn!, \!\pcol@freshpage! and
% \!\pcol@output@end! to reinitialize the parameters of single-column float
% placement at the beginning of a \colpage{} or that of \postenv.  The macro
% lets \!\@mparbottom! and \!\@textfloatsheight! be 0 and then invokes
% \!\@floatplacement!, as \!\@opcol! does its tail.  In addition, the macro
% lets \!\pcol@textfloatsep! be \!\maxdimen! to mean the new \colpage{} does
% not have \sync{}ation point at initial.
% 
%    \begin{macrocode}
\def\pcol@floatplacement{%
  \global\@mparbottom\z@ \global\@textfloatsheight\z@
  \global\pcol@textfloatsep\maxdimen
  \@floatplacement}

%    \end{macrocode}
% \end{macro}
% 
% 
% 
% \subsection{Column-Switching}
% \label{sec:imp-sout-switch}
% 
% \begin{macro}{\pcol@output@switch}
% The macro \!\pcol@output@switch! is invoked from
% \!\pcol@specialoutput! to process the special \!\output! request made in
% \!\pcol@switchcol! and to switch from a column $c=\!\pcol@currcol!$ to
% $d=\!\pcol@nextcol!$ which can be $c$.  The macro also is invoked from
% \!\pcol@makeflushedpage! to \sync{}e and to flush all \ccolpage{}s
% but staying in $c$.
% 
% First, we acquire an \!\insert! to be $\cc_c(\vb)$ and to store the
% \ccolpage{} built in \!\@holdpg!, from \!\@freelist! by
% \!\@next!.  Then, if the \colpage{} has footnotes, we acquire another
% \!\insert! to be $\cc_c(\ft)$ to which all items \!\box!,
% \!\count!, \!\dimen! and \!\skip! of \!\footins! are moved.  Otherwise,
% i.e., no footnotes in the \colpage{}, $\cc_c(\ft)$ is let be \!\voidb@x!.
% 
% Then if $c=0$, we invoke \!\pcol@setpageno! to reflect the jump of
% \!\c@page! made in the building process of the \colpage{} to $\pp(q)$ for
% all $q\in[p,\ptop]$.  After that, we save $c$'s \cctext{} into $\cc_c$ by
% \!\pcol@setcurrcol! and let $\cc_c(\vb^p)=p$ and
% $\cc_c(\vb^r)=\!\@colroom!$.
% 
%    \begin{macrocode}
%% Special Output Routines: Column-Switching

\def\pcol@output@switch{%
  \@next\@currbox\@freelist{\global\setbox\@currbox\box\@holdpg}\pcol@ovf
  \ifvoid\footins
    \def\pcol@currfoot{\voidb@x}%
  \else
    \@next\pcol@currfoot\@freelist{%
      \global\setbox\pcol@currfoot\box\footins
      \global\count\pcol@currfoot\count\footins
      \global\dimen\pcol@currfoot\dimen\footins
      \global\skip\pcol@currfoot\skip\footins}\pcol@ovf
  \fi
  \ifnum\pcol@currcol=\z@ \pcol@setpageno \fi
  \pcol@setcurrcol
  \global\count\@currbox\pcol@page
  \global\dimen\@currbox\@colroom
%    \end{macrocode}
% 
% Next, $\CSIndex{ifpcol@sync}=\true$ for \sync{}ation and
% $\CSIndex{ifpcol@mctext}=\true$ to mean the \colpage{} suspends after a
% \mctext, we {\em broadcast} the \CSIndex{if@nobreak} if true and tokens in
% $\!\everypar!=\cc_c(\ep)$ for the page break inhibition to all columns
% $e\In0\C$ so as to inhibit page break at the \sync{}ation point and after
% the first line following it in any columns.  That is, for each column $e$,
% we restore its \cctext{} from $\cc_e$ by \!\pcol@getcurrcol!, let
% $\CSIndex{if@nobreak}=\true$ if it is true in $c$ ($=0$) and
% $\!\everypar!=\cc_c(\ep)$, and then save the context to $\cc_e$ by
% \!\pcol@setcurrcol! so that $\cc_e(\sw)=1$ or 2 according to the saved
% state of \CSIndex{if@afterindent} and $\cc_e(\ep)=\cc_c(\ep)$.  Note
% that this broadcast is essential when the \mctext{} has sectioning
% commands, and broadcasting of \!\everypar! is natural even when it does
% not have sectioning because all columns may be considered following the
% \mctext.
% 
% \changes{v1.0}{2011/10/10}
%	{Restrict the broadcast of \cs{if@nobreak} and \cs{everypar} only
%	 when a column-switching is accompanied with multi-column text.}
% 
%    \begin{macrocode}
  \@tempswafalse
  \ifpcol@sync
    \ifpcol@mctext
      \if@nobreak \@tempswatrue \fi
      \@temptokena\everypar
      \pcol@currcol\z@ \@whilenum\pcol@currcol<\pcol@ncol\do{%
        \pcol@getcurrcol \if@tempswa \@nobreaktrue \fi
        \everypar\@temptokena
        \pcol@setcurrcol
       \advance\pcol@currcol\@ne}%
    \fi
    \@tempswatrue
    \global\pcol@mctextfalse
  \fi
%    \end{macrocode}
% 
% Finally we invoke \!\pcol@sync! for the \sync{}ation if
% \CSIndex{ifpcol@sync} or \CSIndex{ifpcol@clear} is $\true$, and then
% \!\pcol@restartcolumn! to restart the \ccolpage{} $d$ if
% $\CSIndex{ifpcol@clear}={}\false$.
% 
%    \begin{macrocode}
  \ifpcol@clear \@tempswatrue \fi
  \if@tempswa \pcol@sync \fi
  \ifpcol@clear\else \pcol@restartcolumn \fi}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@restartcolumn}
% \changes{v1.0}{2011/10/10}
%	{Add \cs{pcol@getcurrfoot} to restore parameters of $\kappa_c(\tau)$
%	 into \cs{footins}.}
% 
% The macro \!\pcol@restartcolumn! is invoked from \!\pcol@output@switch! or
% \!\pcol@freshpage! to restart the \ccolpage{} $d=\!\pcol@nextcol!$ which
% becomes $c=\!\pcol@currcol!$ by the very first assignment in this macro.
% Then we restore the \cctext{} in $\cc_c$ by \!\pcol@getcurrcol! and let
% $p=\cc_c(\vb^p)$ and $\!\@colroom!=\cc_c(\vb^r)$ before returning
% $\cc_c(\vb)$ to \!\@freelist! by \!\@cons! because it has become useless
% so far.  We also restore the \pctext{} of $p$ by \!\pcol@getcurrpage!.
% 
% Then we move everything in $\cc_c(\ft)$ into \!\footins! by
% \!\pcol@getcurrfoot!, and, if $\cc_c(\ft^b)$ was not void,
% \!\insert! its contents into \!\footins! itself by \!\unvbox!, returning
% $\cc_c(\ft)$ to \!\@freelist!.  Note that for the safe garbage collection
% of $\cc_c(\ft)$ we return it to \!\@freelist! if not void and then 
% invoke \!\pcol@getcurrfoot! because the latter makes $\cc_c(\ft^b)$
% void.  After that, we put the contents of $\cc_c(\vb^b)$ being the
% \ccolpage{} to the main vertical list by \!\unvbox!.  We also put
% $\!\penalty!=10000$ by \!\nobreak! if $\CSIndex{if@nobreak}=\true$ or
% \!\interlinepenalty! by \!\addpenalty!\footnote{
% 
% As done in \!\@specialoutput! but \!\penalty!\!\interlinepenalty! should
% be sufficient.}
% 
% otherwise to the list as the page break penalty at the returning point.
% 
%    \begin{macrocode}
\def\pcol@restartcolumn{%
  \global\pcol@currcol\pcol@nextcol
  \pcol@getcurrcol
  \global\pcol@page\count\@currbox
  \global\@colroom\dimen\@currbox
  \@cons\@freelist\@currbox
  \pcol@getcurrpage
  \ifvoid\pcol@currfoot\else \@cons\@freelist\pcol@currfoot \fi
  \pcol@getcurrfoot
  \ifvoid\footins\else \insert\footins{\unvbox\footins}\fi
  \unvbox\@currbox
  \if@nobreak \nobreak \else \addpenalty\interlinepenalty \fi}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@getcurrcol}
% \begin{macro}{\pcol@igetcurrcol}
% \begin{macro}{\pcol@iigetcurrcol}
% \changes{v1.0}{2011/10/10}
%	{Add restoration of \cs{pcol@textfloatsep}.}
% 
% The macro \!\pcol@getcurrcol! is invoked from the following macros to
% restore the typesetting parameters of the column $c=\!\pcol@currcol!$ from
% $\cc_c$.
% 
% \begin{itemize}\item[]\begin{tabular}{lll}
% \!\pcol@output@start!&\!\pcol@output@switch!&\!\pcol@restartcolumn!\\
% \!\pcol@flushcolumn!&\!\pcol@measurecolumn!&\!\pcol@synccolumn!\\
% \!\pcol@makeflushedpage!&\!\pcol@flushfloats!&\!\pcol@freshpage!\\
% \!\pcol@output@end!
% \end{tabular}
% \end{itemize}
% 
% Since we represent $\cc_c$ as;
% 
% \begin{eqnarray*}
% &&\Arg{\cc_c(\vb)}\Arg{\cc_c(\ft)}\Arg{\cc_c(\pd)}\Arg{\cc_c(\tl)}
% \Arg{\cc_c(\ml)}\Arg{\cc_c(\bl)}\Arg{\cc_c(\dl)}\Arg{\cc_c(\tf)}|%|\\
% &&\Arg{\Arg{\cc_c(\fh)}\Arg{\cc_c(\mb)}\Arg{\cc_c(\tn)}\Arg{\cc_c(\tr)}
%        \Arg{\cc_c(\bn)}\Arg{\cc_c(\br)}\Arg{\cc_c(\cn)}\Arg{\cc_c(\sw)}
%        \Arg{\cc_c(\ep)}}
% \end{eqnarray*}
% 
% in the body of $|\pcol@col|{\cdot}c$,
% 
% \SpecialArrayIndex{c}{\pcol@col}
% 
% we restore first eight by \!\pcol@igetcurrcol! giving everything above as
% its arguments by double expansion of
% $$
% \!\csname!| pcol@col|\!\number!\!\pcol@currcol!\!\endcsname!
% $$
% and then of the resulting control sequence.  Then this macro gives its
% nineth argument to \!\pcol@iigetcurrcol! which restores the last nine.
% 
% Note that the restore operation is \!\global!, except for $\cc_c(\vb)$ and
% $\cc_d(\ft)$, including \CSIndex{if@nobreak} for which \!\@nobreaktrue!
% and \!\@nobreakfalse! are defined \!\global! by \LaTeX.  Also note that
% \!\dimen!-type parameters are saved in the form of integers and thus
% restoring them needs to specify the unit |sp|.
% 
%    \begin{macrocode}
\def\pcol@getcurrcol{%
  \expandafter\expandafter\expandafter\pcol@igetcurrcol
    \csname pcol@col\number\pcol@currcol\endcsname}
\def\pcol@igetcurrcol#1#2#3#4#5#6#7#8#9{%
  \def\@currbox{#1}\def\pcol@currfoot{#2}\global\pcol@prevdepth#3sp\relax
  \gdef\@toplist{#4}\gdef\@midlist{#5}\gdef\@botlist{#6}\gdef\@deferlist{#7}%
  \global\pcol@textfloatsep#8sp\pcol@iigetcurrcol#9}
\def\pcol@iigetcurrcol#1#2#3#4#5#6#7#8#9{%
  \global\@textfloatsheight#1sp\relax \global\@mparbottom#2sp\relax
  \global\@topnum#3\relax \global\@toproom#4sp\relax
  \global\@botnum#5\relax \global\@botroom#6sp\relax
  \global\@colnum#7\relax
  \global\@afterindentfalse \@nobreaktrue
  \ifcase#8
    \@nobreakfalse \or
    \global\@afterindenttrue \else
    \relax
  \fi
  \global\everypar{#9}}
%    \end{macrocode}
% \end{macro}\end{macro}\end{macro}
% 
% \begin{macro}{\pcol@getcurrfoot}
% The macro \!\pcol@getcurrfoot! is invoked from \!\pcol@restartcolumn!,
% \!\pcol@flushcolumn! and \!\pcol@makeflushedpage! to put everything in
% $\cc_c(\ft)=\!\pcol@currfoot!$ into \!\footins!.  That is, if
% $\cc_c(\ft^b)$ is void, we let $\!\box!{\cdot}\!\footins!$ be so.
% Otherwise, we move \!\box!, \!\count!, \!\dimen! and \!\skip! of
% $\cc_c(\ft)$ into those of \!\footins!\footnote{
% 
% Moving \!\count!, \!\dimen! and \!\skip! is redundant almost always
% because it is very unlikely that these footonote parameters are modified
% dynamically.  Moreover, dynamic modification of them is hardly consistent
% with repetitive self-\!\insert!ion of \!\footins! in
% \!\pcol@restartcolumn! and \!\@reinserts! of \LaTeX.  However, we dare to
% move them in order to, for example, allow each column has its own footnote
% parameters.}.
% 
% 
%    \begin{macrocode}
\def\pcol@getcurrfoot{%
  \ifvoid\pcol@currfoot \global\setbox\footins\box\voidb@x
  \else
    \global\setbox\footins\box\pcol@currfoot
    \global\count\footins\count\pcol@currfoot
    \global\dimen\footins\dimen\pcol@currfoot
    \global\skip\footins\skip\pcol@currfoot
  \fi}
%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@setcurrcol}
% \begin{macro}{\pcol@setcurrcolnf}
% The macro \!\pcol@setcurrcol! is invoked from \!\pcol@output@switch!,
% \!\pcol@measurecolumn! and \!\pcol@synccolumn! to save \cctext{} of
% $c=\!\pcol@currcol!$ in $\cc_c$.  It is also used in \!\pcol@setcurrcolnf!
% invoked from \!\pcol@output@start!, \!\pcol@flushcolumn!,
% \!\pcol@makeflushedpage!, \!\pcol@flushfloats! and \!\pcol@freshpage! for
% the saving when the \colpage{} is known to have no footnotes.
% 
% The macro \!\pcol@setcurrcol! at first calculates the combined code for
% \CSIndex{if@nobreak} and \CSIndex{if@afterindent}, and then saves
% parameters into $\cc_c$ by \!\xdef! to have the sequence shown in the
% description of \!\pcol@getcurrcol!.  Note that \!\dimen!-type parameters
% are saved by expansions with \!\number! and thus as decimal numbers.
% 
% The macro \!\pcol@setcurrcolnf! \!\def!ines $\cc_c(\ft)=\!\pcol@currfoot!$
% as \!\voidb@x!, and then invoke \!\pcol@setcurrcol! for saving.
% 
% \changes{v1.0}{2011/10/10}
%	{Add save of \cs{pcol@textfloatsep}.}
% 
%    \begin{macrocode}
\def\pcol@setcurrcol{{\let\@elt\relax
  \@tempcnta\if@nobreak\if@afterindent\@ne\else\tw@\fi\else\z@\fi
  \expandafter\xdef\csname pcol@col\number\pcol@currcol\endcsname{%
    {\@currbox}{\pcol@currfoot}{\number\pcol@prevdepth}%
    {\@toplist}{\@midlist}{\@botlist}{\@deferlist}{\number\pcol@textfloatsep}%
    {{\number\@textfloatsheight}{\number\@mparbottom}%
     {\number\@topnum}{\number\@toproom}{\number\@botnum}{\number\@botroom}%
     {\number\@colnum}{\number\@tempcnta}{\the\everypar}}}}}
\def\pcol@setcurrcolnf{\def\pcol@currfoot{\voidb@x}\pcol@setcurrcol}

%    \end{macrocode}
% \end{macro}\end{macro}
% 
% 
% 
% \subsection{Syncronization}
% \label{sec:imp-sout-sync}
% 
% \begin{macro}{\pcol@sync}
% \changes{v1.0}{2011/10/10}
%	{Add measurement of $D_T$.}
% 
% The macro \!\pcol@sync! is invoked solely from \!\pcol@output@switch! for
% \exsync{} with page flushing ($\CSIndex{ifpcol@clear}=\true$) or without
% it.  First we invoke \!\pcol@flushcolumn! for all $c\In0\C$ to flush the
% \ccolpage{} of $c$ into $\S_c$ if the \colpage{} is not in $\ptop$, i.e.,
% $\cc_c(\vb^p)<\ptop$ and then, if we have deferred floats, to
% ship out following \fpage{}s up to $\ptop-1$ into $\S_c$ and to place top
% and/or bottom floats in $\ptop$.  Then we ship out all pages $p$ such that
% $p<\ptop$ by \!\pcol@outputpage! giving argument 1.  After that, we obtain
% the \pctext{} of $\ptop$ by \!\pcol@getcurrpinfo!.
% 
% Next, we measure the vertical sizes of the contents in the \ccolpage{} of
% $c$ which is now in $\ptop$ for all $c\In0\C$ by \!\pcol@measurecolumn! as
% follows, where $h(x)$ and $d(x)$ are the height and depth of an object $x$
% respectively.
% 
% \begin{eqnarray*}
% \sigma&=&\rlap{\!\floatsep!}\hskip8em
% \sigma_t=\cases{\cc_c(\tf)&     $\cc_c(\tf)<\infty$\cr
% 		    \!\textfloatsep!&$\cc_c(\tf)=\infty$}\qquad
% \sigma_b=\!\textfloatsep!\\
% \Uidx\fc(t)&=&\rlap{$\displaystyle(\cc_c(\tl)\neq())$}\hskip8em
%     \fc(m)=(\cc_c(\vb)\neq\!\vbox!|{}|)\\
% \fc(f)&=&\rlap{$\displaystyle(\cc_c(\ft)\neq\mathit{void})$}\hskip8em
%     \fc(b)=(\cc_c(\bl)\neq())\\
% \Uidx\Fc(X)&=&\exists x\in X:\fc(x)\\
% \Uidx\vc(t)&=&\!\skip!{\cdot}\cc_c(\vb)=
% 	\sum_{\Sub{\phi\in\cc_c(\tl)}}(h(\phi)+d(\phi))+
% 	(\Abs{\cc_c(\tl)}-1)\cdot\sigma+\sigma_t\\
% \vc(m)&=&h(\cc_c(\vb))+d(\cc_c(\vb))\\
% \vc(f)&=&h(\cc_c(\ft))+d(\cc_c(\ft))\\
% \vc(b)&=&\sum_{\Sub{\phi\in\cc_c(\bl)}}(h(\phi)+d(\phi))+
% 	(\Abs{\cc_c(\bl)}-1)\cdot\sigma+\sigma_b\\
% \vc(b')&=&\vc(b)+\sigma_b\\
% \pd_c&=&\cases{\cc_c(\pd)&$\fc(m)$\cr
%                \infty   &$\lnot \fc(m)$}\\
% \Uidx\size_c(x)&=&\cases{\vc(x)&$\fc(x)$\cr
%                     0     &$\lnot \fc(x)$}\\
% \Uidx\Size_c(X)&=&\cases{\displaystyle\sum_{x\in X}\size_c(x)&$\Fc(X)$\cr
%                          -\infty&                         $\lnot \Fc(X)$}\\
% \Uidx\VT&=&\!\@tempdima!=\max_{0\leq c<\C}\{\Size_c(\{t,m\})\}\\
% \Uidx\VB&=&\!\@tempdimb!=\max_{0\leq c<\C}\{\size_c(f)+\size_c(b)\}\\
% \Uidx\VP&=&\!\pcol@colht!=\max_{0\leq c<\C}\{\Size_c(\{t,m,f,b'\})\}\\
% \Uidx\DT&=&\!\@tempdimc!=\min\Set{\pd_c}{\Size_c{\{t,m\}=\VT}}\\
% \Uidx\dc&=&\cases{
%   0&			$\fc(b)$\cr
%   d(\cc_c(\ft))&	$\lnot \fc(b)\land \fc(f)$\cr
%   d(\cc_c(\pd))&	$\lnot \fc(b)\land\lnot \fc(f)$}\\
% \Uidx\DP&=&\!\@pagedp!=\min\Set{\dc}{\Size_c(\{t,m,f,b'\})=\VP}\\
% \end{eqnarray*}
% 
% That is, $\VT$ is the maximum of combined vertical size (height plus
% depth) of the top floats and the main vertical list, and $\VB$ is that of
% the footnotes and bottom floats.  $\VP$ is the maximum of the sum of all
% four sizes but we add \!\textfloatsep! if the tallest column has bottom
% floats.  Note that $\VT$ and $\VP$ are $-\infty$ if any \colpage{}s don't
% have corresponding items, while $\VB=0$ if so.
% 
% $\DT$ and $\DP$ are the minimum $\pd_c$ and $\dc$ respectively among those
% gives $\VT$ and $\VP$ respectively, where $\pd_c$ is $\cc_c(\pd)$ if
% $f_m=\true$ or $\infty$ otherwise, and $\dc$ is 0 if $c$ has bottom float,
% or the depth of the last footnote if any and without any bottom float, or
% $\cc_c(\pd)$ otherwise.  The reason why $\DT$ and $\DP$ have minimums is
% that they are set into \!\prevdepth! for the items just following the
% \sync{}ation point, and thus a smaller value results in a larger interline
% skip and the special value $-1000\,|pt|$ to inhibit the skip is given the
% highest priority.
% 
% Note that $\VP$ and $\DP$ are only for the \lpage{} and thus referred to
% only by \!\pcol@output@end! to close the environment.  The reason why we
% add \!\textfloatsep! to $\VP$ is to make the last page is well separated
% from the \postenv{} if the tallest column, taking the addition into
% account, has bottom floats.
% 
% As described above, any items can be empty, naturally for top floats,
% footnotes and bottom floats, but also including main vertical lists if the
% \ccolpage{}s were not in $\ptop$ before the invocation of
% \!\pcol@flushcolumn!.  Moreover, all main vertical lists can be empty if
% all \lcolpage{}s just have started (by \!\newpage!, for example).  More
% weirdly, the case of all-empty main vertical lists can be accompanied with
% non-empty top floats when columns have floats which cannot be put in
% $\ptop-1$ but are found to be placed in $\ptop$.
%
% Therefore, we have to take care of the case $\VT<0$ to mean that all top
% floats and main vertical lists are empty\footnote{
% 
% In usual cases, but it can mean some of them have negative vertical
% sizes.  Even though we can detect such a very unlikely special case, it is
% very tough to define the reasonable \sync{}ation point above the top of
% $\ptop$.  Therefore, we assume the point is at the top of $\ptop$ and thus
% do nothing.},
% 
% i.e., $\Fc(\{t,m\})=\false$ for all $c\In0\C$, to let succeeding stuff in
% all \ccolpage{}s are put as if they are preceded by a \!\flushpage!.  In
% other words, we do nothing if $\VT<0$.
% 
% Then if $\VT\geq0$, we set the \sync{}ation point $\VT$ below the top of
% $\ptop$.  However, since the \sync{}ation {\em pushes down} everything
% below the main vertical list, footnotes and bottom floats in a \colpage{}
% $c$ such that $\Size_c(\{t,m\})<\VT$ may be overflown from the bottom of
% the page.  Therefore, we examine $\VT+\VB\geq\!\@colht!$ (it can be
% $\VT+\VB>\VP$) and if so flush all \ccolpage{}s in $\ptop$ to set the
% \sync{}ation point at the top of the next page $\ptop+1$.  This flush is
% also done when it is requested explicitly by
% $\CSIndex{ifpcol@clear}=\true$.  That is, we let
% $\CSIndex{if@tempswa}=\true$ iff one of them holds to flush the
% \colpage{}s in \!\pcol@synccolumn! invoked for each $c\In0\C$, which sets
% the \sync{}ation point otherwise.  This macro also takes care of the case
% of $\VT\geq0$ but empty main vertical lists as the special case that $\VT$
% is given by a column whose main vertical list is empty, i.e., its top
% float defines the \sync{}ation point.  In such a case in which we have
% $\DT=\infty$, the macro sets the \sync{}ation point at the top of the
% page for the main vertical list and enlarges the space for top floats if
% necessary.
% 
% Finally, we let $\CSIndex{ifpcol@sync}=\false$ to give the default for the
% next invocation of \!\pcol@output@switch!.
% 
%    \begin{macrocode}
%% Special Output Routines: Synchronization

\def\pcol@sync{%
  \pcol@currcol\z@ \@whilenum\pcol@currcol<\pcol@ncol\do\pcol@flushcolumn
  \pcol@outputpage\@ne
  \pcol@getcurrpinfo\@currbox{\global\c@page}{\global\@colht}{\global\topskip}%
  \@tempdima-\maxdimen \@tempdimb-\maxdimen \pcol@colht-\maxdimen
  \@tempdimc\maxdimen \@pagedp\maxdimen
  \pcol@currcol\z@ \@whilenum\pcol@currcol<\pcol@ncol\do\pcol@measurecolumn
  \ifdim\@tempdima<\z@\else
    \advance\@tempdimb\@tempdima
    \@tempswafalse
    \ifdim\@tempdimb<\@colht \ifpcol@clear\else
      \@tempswatrue
    \fi\fi
    \pcol@currcol\z@ \@whilenum\pcol@currcol<\pcol@ncol\do\pcol@synccolumn
  \fi
  \global\pcol@syncfalse}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@flushcolumn}
% \changes{v1.0}{2011/10/10}
%	{Rename \cs{pcol@maxpage} as \cs{pcol@toppage}.}
% \changes{v1.0}{2011/10/10}
%	{Add \cs{vfil} at the bottom of flushed column-page.}
% \changes{v1.0}{2011/10/10}
%	{Change order of the garbage collection of \cs{pcol@currfoot} and
%	 \cs{pcol@getcurrfoot}.} 
% 
% The macro \!\pcol@flushcolumn! is invoked for each column $c\In0\C$ from
% \!\pcol@sync! to ship out the \ccolpage{} of $c$ into $\S_c$ if it is not
% leading one\Index{leading column-page}, i.e., $p=\cc_c(\vb^p)<\ptop$.  The
% macro also ships out \fpage{}s from $p+1$ up to $\ptop-1$ if we have
% deferred floats to fill them and, if this float flushing still leaves
% deferred floats, puts some of them to the \lcolpage{} being
% current\Index{current column-page}{} now as its top and/or bottom floats.
% 
% First we obtain the \cctext{} in $\cc_c$ by \!\pcol@getcurrcol! and
% examines if $p=\cc_c(\vb^p)<\ptop$.  If it does not hold to mean $c$ has
% \lcolpage{}, we do nothing.
% 
% Otherwise, we put the contents of the \ccolpage{} $\cc_c(\vb^b)$ adding
% \!\vfil! at its tail into \!\box!|255| being the \TeX's standard interface
% to carry the main vertical list for \!\output! routine.  We also move
% everything in $\cc_c(\ft)$ obtained by \!\pcol@getcurrfoot! into
% \!\footins! and return $\cc_c(\ft)$ to \!\@freelist! if $\cc_c(\ft^b)$ is
% not void.  Then after obtaining $p$'s \pctext{} by \!\pcol@getcurrpage!,
% we invoke \!\@makecol!\footnote{
% 
% Not \!\pcol@makecol! because \!\box!\texttt{255} has \!\vfil! at its
% tail and the \colpage{} should be short enough.}
% 
% to build the complete \colpage{} in \!\@outputbox! to be
% added to the tail of $\S_c$ by \!\@cons!, with the following
% setting\footnote{
% 
% \LaTeX's has another \!\insert! named \!\@kludgeins! for \!\enlargepage!
% but \Paracol{} does not cares about it.}.
% $$
% \begin{array}{lll}
% \!\box!|255|=\cc_c(\vb^b)&
% \!\footins!=\cc_c(\ft)&
% \!\@colht!=\pp^h(\cc_c(\vb^p))\\
% \!\@midlist!=\cc_c(\ml)&
% \!\@toplist!=\cc_c(\tl)&
% \!\@botlist!=\cc_c(\bl)
% \end{array}
% $$
% 
%    \begin{macrocode}
\def\pcol@flushcolumn{%
  \pcol@getcurrcol
  \ifnum\count\@currbox<\pcol@toppage
    \pcol@page\count\@currbox
    \setbox\@cclv\vbox{\unvbox\@currbox \vfil}%
    \ifvoid\pcol@currfoot\else \@cons\@freelist\pcol@currfoot \fi
    \pcol@getcurrfoot
    \pcol@getcurrpage
    \@makecol
    \global\setbox\@currbox\box\@outputbox
    \expandafter\@cons\csname pcol@shipped\number\pcol@currcol\endcsname
      \@currbox
%    \end{macrocode}
% 
% Then for each $q\in[p{+}1,\ptop{-}1]$, we repeat the followings; get $q$'s
% \pctext{} by \!\pcol@getcurrpage!; try to make a \fcolumn{} in
% \!\@outputbox! by \!\@makefcolumn! giving it \!\@deferlist! being
% $\cc_c(\dl)$ at initial but will be shrunk; if the \fcolumn{} is made,
% acquire an \!\insert! by \!\@next! to keep the contents of \!\@outputbox!
% and to be added to the tail of $\S_c$ by \!\@cons!.
% 
%    \begin{macrocode}
    \advance\pcol@page\@ne
    \ifx\@deferlist\@empty\else
      \@whilenum\pcol@page<\pcol@toppage\do{%
        \pcol@getcurrpage
        \@makefcolumn\@deferlist
        \if@fcolmade
          \@next\@currbox\@freelist{\global\setbox\@currbox\box\@outputbox}%
            \pcol@ovf
          \expandafter\@cons
            \csname pcol@shipped\number\pcol@currcol\endcsname\@currbox
        \fi
       \advance\pcol@page\@ne}%
    \fi
%    \end{macrocode}
% 
% Next, we acquire the \ccolpage{} of $c$ which is now in $\ptop$ and thus
% is empty by \!\@next!.  Then we let $\!\@colht!=\!\@colroom!=\pp^h(\ptop)$
% by \!\pcol@getcurrpinfo!, and reinitialize the float placement parameters by
% \!\pcol@floatplacement!.  Then, if $\cc_c(\dl)$ still has some floats,
% we make a \fcolumn{} for some of them in the \tpage{} by
% \!\pcol@makefcolumn! if $\CSIndex{ifpcol@clear}={}\true$ meaning flushing,
% or try to move some of them to $\cc_c(\tl)=\!\@toplist!$ or
% $\cc_c(\bl)=\!\@botlist!$ by \!\pcol@trynextcolumn! otherwise.  Note that
% since \!\@colroom! is used in \!\pcol@makefcolumn! as a working register,
% we let $\!\@colroom!=\pp^h(\ptop)$ again after its invocation.  After that
% we save \cctext{} including those given by \!\pcol@floatplacement! and
% modified by \!\pcol@trynextcolumn!  into $\cc_c$ by \!\pcol@setcurrcolnf!
% because all footnotes are shipped out, and let $\cc_c(\vb^p)=\ptop$ and
% $\cc_c(\vb^r)=\!\@colroom!$ possibly modified by \!\pcol@trynextcolumn!
% too.
% 
% \changes{v1.0}{2011/10/10}
%	{Add $\cs{@colht}\EQ\pi^h(p)$.}
% \changes{v1.0}{2011/10/10}
%	{Replace \cs{pcol@trynextcolumn} with \cs{pcol@makefcolumn} for the
%	 case of $\cs{ifpcol@clear}\EQ\mathit{true}$.}
% 
%    \begin{macrocode}
    \@next\@currbox\@freelist{\global\setbox\@currbox\vbox{}}\pcol@ovf
    \pcol@getcurrpinfo\reserved@a\@tempcnta{\global\@colht}\@tempskipa
    \global\@colroom\@colht \pcol@floatplacement 
    \ifx\@deferlist\@empty\else
      \ifpcol@clear
        \pcol@makefcolumn \global\@colroom\@colht
      \else
        \pcol@trynextcolumn
    \fi\fi
    \pcol@setcurrcolnf
    \global\count\@currbox\pcol@page
    \global\dimen\@currbox\@colroom
  \fi %\ifnum\count\@currbox<\pcol@toppage
  \advance\pcol@currcol\@ne}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@makefcolumn}
% \changes{v1.0}{2011/10/10}
%	{Introduced to take special care of the float-column in the last
%	 page. }
% 
% The macro \!\pcol@makefcolumn! is invoked solely from \!\pcol@flushcolumn!
% to put deferred floats in the currently empty \colpage{} of $c$ in the
% \tpage{} $\ptop$ which is being flushed.  Since we have to take special care
% of the case of environment closing, we cannot do this operation by
% \!\@makefcolumn!\footnote{
% 
% We can do it for other cases of \!\flushpage! and \!\clearpage! but
% \!\pcol@makefcolumn! covers it easily.}.
% 
% First, we scan the copy of $\cc_c(\dl)$ applying \!\pcol@makefcolelt! to
% each element to have the floats to be put in \!\@toplist!, which is
% assuredly empty because the \ccolpage{} of $c$ has already been shipped
% out to empty it, and those still deferred in $\cc_c(\dl)$.  Prior to scan,
% we let $H_r=\pp^h(\ptop)+\alpha$ as the space initially available for
% floats each of which being $\phi$ is assumed to consume
% $v(\phi)=h(\phi)+d(\phi)+\alpha$, and $H_t=\!\@colroom!=-\alpha$ as the
% initial value of the accumulated size of $v(\phi)$ for all $\phi$ to be
% put, where $\alpha=\!\floatsep!$ if $\CSIndex{ifpcol@lastpage}=\true$
% 
% \SpecialIndex{\ifpcol@lastpage}
% 
% as discussed afterward, or $\alpha=\!\@fpsep!$ otherwise.
% 
% Then if the resulting \!\@toplist! is not empty\footnote{
% 
% It can happen if the first float is larger than $\pp^h(\ptop)$.},
% 
% we examine if $\ptop$ is the \lpage{} ($|\ifpcol@|\~|lastpage|=\true$)
% and $\cc_c(\dl)$ is empty to mean the last \colpage{} have all deferred
% floats.  This case is subtle because if we make the \colpage{} a \fcolumn{}
% it can be sparse and unnecessarily throw the \postenv{} to the next
% page.  Therefore, we intend to pack floats to the page top as top floats
% and thus have let $\alpha=\!\floatsep!$ in the building process of
% \!\@toplist! above\footnote{
% 
% We dare to do it knowing the natural component of \!\floatsep! is a little
% bit (4pt) larger than that \!\@fpsep! and the possibility of having
% fewer floats than those given by \!\@makefcolumn!.},
% 
% but it may make a too tall \colpage{} only having floats shrinking
% the \postenv{} in the page.  In addition, if other columns have
% \fpage{}s in the \lpage, packing the floats as top floats should give
% inconsistent appearance but we don't know whether the columns following
% $c$ has \fpage{}s.  Therefore, we performs this float packing if making
% the \fpage{} gives too sparse, more specifically if
% $H_t<\!\floatpagefraction!\times\pp^h(\ptop)=\!\@fpmin!$, but postpone the
% final decision until all columns are processed by \!\pcol@flushcolumn!.
% That is, if the all conditions above hold, we keep \!\@toplist! so that it
% is saved in $\cc_c(\tl)$ and let $\cc_c(\tr)=\infty$ to indicate that the
% column has pending floats.
% 
% Otherwise, i.e., if we make a \fcolumn{} in the \lpage, we put all floats in
% \!\@toplist! in $\cc_c(\vb^b)$ of $\pp^h(\ptop)$ tall, together with
% \!\vskip!  of \!\@fptop! and \!\@fpbot! at the top and bottom and that of
% \!\@fpsep!  between floats as \!\@makefcolumn! does.  Note that the last
% \!\vfilneg! is to cancel \!\vfil! which will be inserted at the bottom by
% \!\pcol@synccolumn!.  Then we return all floats in \!\@toplist! to
% \!\@freelist! and empty the list.
% 
%    \begin{macrocode}
\def\pcol@makefcolumn{%
  \ifpcol@lastpage \@tempdimc\floatsep \else \@tempdimc\@fpsep \fi
  \@tempdima\@colht \advance\@tempdima\@tempdimc \global\@colroom-\@tempdimc
  \begingroup
    \let\@elt\pcol@makefcolelt
    \let\reserved@b\@deferlist
    \global\let\@deferlist\@empty
    \reserved@b
  \endgroup
  \ifx\@toplist\@empty\else
    \@tempswatrue
    \ifpcol@lastpage \ifx\@deferlist\@empty \ifdim\@colroom<\@fpmin
      \@tempswafalse \global\@toproom\maxdimen
    \fi\fi\fi
    \if@tempswa
      \setbox\@currbox\vbox to\@colht{\vskip\@fptop \vskip-\@fpsep
        \def\@elt##1{\vskip\@fpsep\box##1}\@toplist \vskip\@fpbot \vfilneg}%
      \xdef\@freelist{\@freelist\@toplist}%
      \global\let\@toplist\@empty
    \fi
  \fi}
%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@makefcolelt}
% \changes{v1.0}{2011/10/10}
%	{Introduced to take special care of the float-column in the last
%	 page. }
% 
% The macro $\!\pcol@makefcolelt!\<\phi\>$ is invoked solely from
% \!\pcol@makefcolumn! to be applied to each float element $\phi$ in (the
% copy of) $\cc_c(\dl)$.  We examine if $v(\phi)=h(\phi)+d(\phi)+\alpha\leq
% H_r$ to mean the \fcolumn{} being built has room large enough for the float
% $\phi$.  If so, we add $\phi$ to \!\@toplist! by \!\@cons!, and let
% $H_r\gets H_r-v(\phi)$ and $H_t\gets H_t+v(\phi)$.  Otherwise, we add
% $\phi$ to $\cc_c(\dl)$ by \!\@cons! to make it deferred again, and
% let $H_r=-\infty$ so that the examinations for any succeeding elements
% fail.
% 
%    \begin{macrocode}
\def\pcol@makefcolelt#1{%
  \@tempdimb\ht#1{}\advance\@tempdimb\dp#1{}\advance\@tempdimb\@tempdimc
  \ifdim\@tempdimb>\@tempdima \@cons\@deferlist#1\relax
    \@tempdima-\maxdimen
  \else \@cons\@toplist#1\relax
    \advance\@tempdima-\@tempdimb \global\advance\@colroom\@tempdimb
  \fi}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@magicpenalty}
% \begin{macro}{\pcol@measurecolumn}
% \changes{v1.0}{2011/10/10}
%	{Drastically changed to measure $D_T$, to deal with empty
%	 main vertical list, and to omit \cs{topfigrule} and \cs{botfigrule}
%	 from float size measurement.} 
% 
% The macro \!\pcol@measurecolumn! is invoked for each column $c\In0\C$ from
% \!\pcol@sync! to measure the sizes of the top floats $\size_c(t)$, main
% vertical list $\size_c(m)$, footnotes $\size_c(f)$ and bottom floats
% $\size_c(b)$ in the \ccolpage{} in the page $\ptop$.  After obtaining the
% \cctext{} in $\cc_c$ by \!\pcol@getcurrcol!, we calculate
% $\size_c(t)=\!\skip!{\cdot}\cc_c(\vb)$ by \!\pcol@addflhd! giving it
% $\cc_c(\tl)$ and \!\pcol@textfloatsep! as its arguments also to have
% $\CSIndex{if@tempswa}=\fc(t)$.  We also calculate
% $\size_c(m)=h(\cc_c(\vb))+d(\cc_c(\vb))$, and then the sum of it and
% $\size_c(t)$.
% 
%    \begin{macrocode}
\def\pcol@magicpenalty{12345}
\def\pcol@measurecolumn{%
  \pcol@getcurrcol
  \@tempswafalse
  \dimen@\z@ \pcol@addflhd\@toplist\pcol@textfloatsep
  \global\skip\@currbox\dimen@
  \advance\dimen@\ht\@currbox \advance\dimen@\dp\@currbox \dimen@ii\dimen@
%    \end{macrocode}
% 
% Next we examine if the main vertical list $\cc_c(\vb^b)$ is empty.
% Unfortunately, \TeX{} does not provide any convenient way for examination,
% we perform a series of tricky operations to put the followings into
% \!\@tempboxa!; a penalty of $\!\pcol@magicpenalty!=12345$ whose existence
% in $\cc_c(\vb^b)$ is (almost) impossible; contents of $\cc_c(\vb^b)$ put
% by \!\unvcopy!; and then a \!\global! \!\def!inition of \!\@gtempa! to let
% it have the decimal representation of \!\lastpenalty!.  Since
% \!\lastpenalty! has $\arg{pen}$ if the last item is
% $\!\penalty!\arg{pen}$, or 0 otherwise,
% $\!\@gtempa!=\!\pcol@magicpenalty!$ iff $\cc_c(\vb^b)$ is empty.
% Therefore if so, we let $\pd_c=\cc_c(\pd)=\infty$ and save it (together
% with others) by \!\pcol@setcurrcol! so that, if the column defines the
% $\VT$ finally by its top floats, $\DT$ is let $\infty$ and the fact that
% the column has empty list is remembered.  Otherwise, we let
% $\pd_c=\cc_c(\pd)$ and $\CSIndex{if@tempswa}=\true$ to represent
% $\Fc(\{t,m\})=f_t\lor f_m$ because $f_m=\true$.  Then we invoke
% \!\pcol@measureupdate! to let $\VT=\size_c(t)+\size_c(m)=\Size_c(\{t,m\})$
% and $\DT=\pd_c$ if $\Fc(\{t,m\})=\true$ and $\VT<\Size_c(\{t,m\})$.  It
% also lets $\DT=\pd_c$ if $\Fc(\{t,m\})=\true$, $\VT=\Size_c(\{t,m\})$ and
% $\DT>\pd_c$.
% 
%    \begin{macrocode}
  \setbox\@tempboxa\vbox{\penalty\pcol@magicpenalty
    \unvcopy\@currbox \xdef\@gtempa{\number\lastpenalty}}%
  \ifnum\@gtempa=\pcol@magicpenalty\relax \global\pcol@prevdepth\maxdimen
    \pcol@setcurrcol
  \else \@tempswatrue
  \fi
  \pcol@measureupdate\@tempdima\dimen@ii\@tempdimc\pcol@prevdepth
%    \end{macrocode}
% 
% Next we let $\size_c(f)=0$ if $\cc_c(\ft^b)$ is void, or otherwise let
% $\size_c(f)=h(\cc_c(\ft^b))+d(\cc_c(\ft^b))+{}\cc_c(\ft^s)$\footnote{
% 
% We ignore the height and depth of \!\footnoterule! because they are
% expected to be 0 and are so in the default setting.}
% 
% and $\CSIndex{if@tempswa}=\true$ because $\fc(f)=\true$ and thus
% $\Fc(\{t,m,f\})=\true$.  After that, we calculate $\size_c(f)+\size_c(b)$
% by \!\pcol@addflhd! giving it $\cc_c(\bl)$ and \!\maxdimen! as its
% argument also to have $\CSIndex{if@tempswa}=\Fc(\{t,m,f,b\})$.  Then we
% let $V_b=\size_c(f)+\size_c(b)$ if $V_b<\size_c(f)+\size_c(b)$, and
% calculate $\size_c(t)+\size_c(m)+\size_c(f)+\size_c(b)$ being
% $\Size_c(\{t,m,f,b\})$ for a non-empty \colpage{}.
% 
%    \begin{macrocode}
  \ifvoid\pcol@currfoot \dimen@\z@
  \else
    \dimen@\ht\pcol@currfoot \advance\dimen@\dp\pcol@currfoot
    \advance\dimen@\skip\pcol@currfoot
    \@tempswatrue
  \fi
  \pcol@addflhd\@botlist\maxdimen
  \ifdim\dimen@>\@tempdimb \@tempdimb\dimen@ \fi
  \advance\dimen@\dimen@ii
%    \end{macrocode}
% 
% Next, we let $\dc$ be the depth of the lowest non-empty items among the
% main vertical list, footnotes and bottom floats.  That is, we let
% $\dc\gets\cc_c(\pd)$ at first, and then override it by $\dc\gets
% d(\cc_c(\ft^b))$ if there are footnotes, and finally override it by
% $\dc\gets0$ for the bottom floats if exist adding \!\textfloatsep! to
% $\Size_c(\{t,m,f,b\})$ to have $\Size_c(\{t,m,f,b'\})$.  After that, we
% throw away the calculation of $\Size_c(\{t,m,f,b'\})$ and $\dc$ above and
% let them be $\pp^h(\ptop)$ and 0 if $\cc_c(\dl)\neq\emptyset$, because the
% \lpage{} should be {\em full size} for the following pages having
% \fcolumn{}s.  Finally, we invoke \!\pcol@measureupdate! again to let
% $\VP=\Size_c(\{t,m,f,b'\})$ and $\DP=\dc$ if $\Fc(\{t,m,f,b\})=\true$ and
% $\VP<\Size_c(\{t,m,f,b'\})$.  It also lets $\DP=\dc$ if
% $\Fc(\{t,m,f,b\})=\true$, $\VP=\Size_c(\{t,m,f,b'\})$ and $\DP>\dc$.
% 
%    \begin{macrocode}
  \dimen@ii\pcol@prevdepth
  \ifvoid\pcol@currfoot\else \dimen@ii\dp\pcol@currfoot \fi
  \ifx\@botlist\@empty\else \dimen@ii\z@ \advance\dimen@\textfloatsep \fi
  \ifx\@deferlist\@empty\else \dimen@\@colht \dimen@ii\z@ \fi
  \pcol@measureupdate\pcol@colht\dimen@\@pagedp\dimen@ii
  \advance\pcol@currcol\@ne}
%    \end{macrocode}
% \end{macro}\end{macro}
% 
% \begin{macro}{\pcol@addflhd}
% \changes{v1.0}{2011/10/10}
%	{Drastically changed to omit \cs{topfigrule} and \cs{botfigrule}
%	 from float size measurement, to take care of top float enlargement,
%	 to add the measurement of $D_T$, and to revise the definition of
%	 $D_P$.}
% 
% \begin{macro}{\pcol@hdflelt}
% \def\xl{\lambda_x}
% 
% The macro $\!\pcol@addflhd!\arg{list}\arg{tfs}$ is invoked twice
% from \!\pcol@measurecolumn! for a column $c$ to measure $\size_c(x)$
% ($x\in\{t,b\}$) of top ($x=t$) or bottom ($x=b$) floats.  The arguments
% and registers referred to in the macro have the folloiwngs according to
% $x=t$ or $x=b$.
% $$
% \nosv\begin{array}{l|ll}
% &		x=t&			x=b\\\hline
% \arg{list}&	\cc_c(\tl)&		\cc_c(\bl)\\
% \arg{tfs}&	\!\pcol@textfloatsep!&	\!\maxdimen!\\
% \CSIndex{if@tempswa}&
%		\false&			\Fc(\{t,m,f\})\\
% \!\dimen@!&	0&			\size(f)
% \end{array}
% $$
% The macro at first examines if $\cc_c(\xl)=\arg{list}$ is empty and does
% nothing if so.  Otherwise, \CSIndex{if@tempswa} is turned $\true$ to have
% $\fc(t)=\true$ for $x=t$ or $\Fc(\{t,m,f,b\})=\true$ for $x=b$.  Then we
% scan all floats in $\arg{list}$ applying \!\pcol@hdflelt! to each float
% $\phi$ to add $h(\phi)+d(\phi)+\!\floatsep!$ to \!\dimen@!, from/to which
% we then subtract \!\floatsep! and add $\sigma_x$ because the last float is
% followed by the vertical skip of $\sigma_x$ instead of \!\floatsep!, to
% have $\size_c(t)$ for $x=t$ or $\size_c(f)+\size_c(b)$ for $x=b$ being
% {\em returned} to \!\pcol@measurecolumn!.
% 
% Note that $\sigma_t$ is $\arg{tfs}=\!\pcol@textfloatsep!$ if it is less
% than $\infty$ or \!\textfloatsep! otherwise, while
% $\sigma_b=\!\textfloatsep!$ always because $\arg{tfs}=\!\maxdimen!$.  Also
% note that $\sigma_t$ can be biased by 10000\,|pt| and thus larger than
% 5000\,|pt|, if we have a \mvlfloat{} in top floats.  Another caution is that
% we ignore the contribution by \!\topfigrule! nor \!\botfigrule! because
% they should insert vertical items whose total height and depth are 0.
% 
%    \begin{macrocode}
\def\pcol@addflhd#1#2{%
  \ifx#1\@empty\else
    \@tempswatrue
    \let\@elt\pcol@hdflelt
    #1\advance\dimen@-\floatsep 
    \ifdim#2=\maxdimen \advance\dimen@\textfloatsep
    \else
      \advance\dimen@\pcol@textfloatsep
      \ifdim\pcol@textfloatsep>5000\p@ \advance\dimen@-\@M\p@ \fi
    \fi
    \let\@elt\relax
  \fi}
\def\pcol@hdflelt#1{\advance\dimen@\ht#1\advance\dimen@\dp#1%
  \advance\dimen@\floatsep}
%    \end{macrocode}
% \end{macro}\end{macro}
% 
% \begin{macro}{\pcol@measureupdate}
% \changes{v1.0}{2011/10/10}
%	{Introduced to let $D_T$ and $D_P$ have the minimum depth of items
%	 among those which give $V_T$ and $V_P$.}
% 
% The macro $\!\pcol@measureupdate!\<V\>\<v\>\<D\>\<d\>$ is invoked
% twice in \!\pcol@measurecolumn! for $c$ to update $\<V\>=V_X$ and
% $\<D\>=D_X$ where $X\in\{T,P\}$ as follows if \CSIndex{if@tempswa}, being
% $\Fc(\{t,m\})$ for $X=T$ or $\Fc(\{t,m,f,b\})$ for $X=P$, is $\true$.
% $$
% \<V\>\gets\max(\<V\>,\<v\>)\qquad
% \<D\>\gets\cases{\min(\<D\>,\<d\>)&$\<V\>=\<v\>$\cr
%                  \<D\>&            $\<V\>\neq\<v\>$}
% $$
% The arguments $\<v\>$ and $\<d\>$ have the followings according to $X$.
% $$
% \arraycolsep0pt
% \begin{array}{rll}
% X=T\;{:}\;&\<v\>=\Size_c(\{t,m\})&\quad \<d\>=\delta_c\\
% X=B\;{:}\;&\<v\>=\Size_c(\{t,m,f,b'))&\quad \<d\>=\dc
% \end{array}
% $$
% 
%    \begin{macrocode}
\def\pcol@measureupdate#1#2#3#4{\if@tempswa
  \ifdim#1<#2\relax#1#2\relax#3#4\relax
  \else\ifdim#1=#2\ifdim#3>#4\relax#3#4\fi\fi\fi\fi}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@synccolumn}
% \changes{v1.0}{2011/10/10}
%	{Drastically changed to correctly implement the top float
%	 enlargement and MVL-float.}
% 
% The macro \!\pcol@synccolumn! is invoked for each column $c\In0\C$ from
% \!\pcol@sync! to set a \sync{}ation point at $\VT$ from the top of the
% \ccolpage{} of $c$ if $\CSIndex{if@tempswa}=\true$, or flush it otherwise.
% After obtaining $c$'s \cctext{} $\cc_c$ by \!\pcol@getcurrcol!, we process
% one of the following three cases.
% 
% The first non-flushing case is for $\DT=\infty$ to mean the \sync{}ation
% point is set just below the top floats of a column whose main vertical
% list is empty.  In this case, we should not put anything back to the main
% vertical list, because the column having defined the point will restart
% from the top of its \colpage{} with \!\topskip! and thus other columns
% should do so for the stuff following the point.  Therefore, we put
% $\cc_c(\vb^b)$ as the last top float, namely {\em\Uidx\mvlfloat} because
% it is for the main vertical list, acquiring an \!\insert! from
% \!\@freelist! by \!\@next! and assigning it to \Midx{\!\pcol@float!} so
% that we pretend main vertical lists of all columns are empty.  The float
% has zero height and depth and $\cc_c(\vb^b)$ is put in it following a
% vertical skip of $-\!\floatsep!$ to go back to the bottom of the last real
% float, and \!\topfigrule! and a skip of \!\textfloatsep! to separate it
% from the last real float, if we have some floats.  Otherwise, neither of
% the skips nor \!\topfigrule! are put because we let
% $\!\floatsep!=\!\textfloatsep!=0$ and $\!\topfigrule!=\!\relax!$
% temporarily in a group.  Then we set the \sync{}ation point by enlarging
% the space below the \mvlfloat{} so that the total size of all floats
% including \!\floatsep! and \!\textfloatsep!, which may be 0 as set in the
% process above, is equal to $\VT$.  This enlarging is done by letting
% $\cc_c(\tf)=\VT-\vc(t)+\!\textfloatsep!-\!\floatsep!$ so as to enlarge the
% space by $h_c^v=\VT-\vc(t)$ replacing \!\textfloatsep! with $\cc_c(\tf)$
% in the top float insertion process\footnote{
% 
% This enlarging cannot be done by making the float's height 
% $h_c^v-\!\floatsep!$ (or \!\textfloatsep!) because the height can be
% negative.}.
% 
% Note that $\cc_c(\tf)$ is then biased by 10000\,|pt| so that \!\pcol@cflt!
% will not put \!\topfigrule! because it has been already put as a part of
% the \mvlfloat{} or we don't have any real floats.  We also let
% $\cc_c(\pd)=1000$ to mean the \colpage{}'s main vertical list is empty, so
% as to mimic \TeX's mechanism of \!\prevdepth! with an empty
% list\footnote{
% 
% The author is not sure if this setting is really necessary but, at least,
% it looks working well (though other setting looks all right too).}.
% 
% Note that \colpage{}s with $\cc_c(\tf)=\infty$ does not have any
% \sync{}ation points, and thus $\cc_c(\tf)<\infty$ means a \sync{}ation has
% already taken place in them.  If this $\cc_c(\tf)<\infty$ happens with
% $\DT=\infty$\footnote{
% 
% This can happen when a \sync{}ation with $\DT=\infty$ is immediately
% followed by another \sync{}ation or, more unlikely, by additions of
% items whose total amount is negative and then a \sync{}ation.},
% 
% we cannot update $\cc_c(\tf)$ because \!\pcol@measurecolumn! took care of
% its value on measuring $\vc(t)$.  Therefore, we do nothing if
% $\cc_c(\tf)<\infty$ but just let succeeding stuff be added to the main
% vertical list as in \cswitch{} without \sync{}ation.
% 
%    \begin{macrocode}
\def\pcol@synccolumn{%
  \pcol@getcurrcol
  \if@tempswa
    \@tempdimb\@tempdima
    \advance\@tempdimb-\skip\@currbox
    \ifdim\@tempdimc=\maxdimen
      \ifdim\pcol@textfloatsep=\maxdimen \begingroup
        \ifx\@toplist\@empty
          \textfloatsep\z@ \floatsep\z@ \let\topfigrule\relax
        \fi
        \@next\pcol@float\@freelist{\global\setbox\pcol@float\vbox to\z@{
          \vskip-\floatsep \topfigrule \vskip\textfloatsep
          \unvbox\@currbox \vss}}\pcol@ovf
        \@cons\@toplist\pcol@float
        \advance\@tempdimb\textfloatsep \advance\@tempdimb-\floatsep
        \advance\@tempdimb\@M\p@
        \global\pcol@prevdepth\@m\p@
        \global\pcol@textfloatsep\@tempdimb
      \endgroup \fi
%    \end{macrocode}
% 
% The second case is also non-flushing but $\DT<\infty$ and thus most
% usual.  In this case, we enclose everything in $\cc_c(\vb^b)$ in a \!\vbox!
% whose height is $h_c^v$ and let $\cc_c(\vb^b)$ have it so that the
% item following the \sync{}ation point start at $\VT$.  An attention we
% have to pay is that it can be $h_c^v<\!\topskip!$ to let \TeX{} insert a
% vertical skip of the difference when the box is returned to the main
% vertical list pushing down the \sync{}ation point a little bit.
% Therefore, if so, we let $\cc_c(\vb^b)$ have the followings; a \!\vbox! of
% \!\topskip! tall having its old contents at its top above which no
% vertical skip will be inserted; a vertical skip $-\!\topskip!$ going back
% to the page top; and a vertical skip $h_c^v$ going down to the
% \sync{}ation point.
% 
% Note that, in both cases of $h_c^v<\!\topskip!$ or not, we insert an
% infinite stretch of $1/1000\,|fil|$ at the bottom of $\cc_c(\vb^b)$ to push
% up its old contents respecting other infinite stretches if any, as done by
% \!\raggedbottom!\footnote{
% 
% This means finite stretches are nullified.  We could respect them by
% obtaining the total amount of them in \!\pagestretch! together with
% infinite ones to let stretches act as much as possible especially with
% \!\flushbottom! setting.  However, this improvement (if so) is too small
% to pay a tough coding effort.}.
% 
% In addition, we let $\cc_c(\pd)=\DT$ to {\em broadcast} $\DT$ to all
% columns by which the baselines of first items following the \sync{}ation
% point are aligned, if $\DT$ plus the hight of each item is less than
% \!\baselineskip!.  Further, we let $\cc_c(\tf)=\!\textfloatsep!$ to
% indicate the \colpage{} has the \sync{}ation point we just have set, if it
% was $\infty$ to mean the point is the first one.
% 
%    \begin{macrocode}
    \else
      \global\pcol@prevdepth\@tempdimc
      \ifdim\pcol@textfloatsep=\maxdimen
        \global\pcol@textfloatsep\textfloatsep \fi
      \global\setbox\@currbox\vbox{
        \ifdim\@tempdimb<\topskip
          \vbox to\topskip{\unvbox\@currbox \vskip\z@\@plus.0001fil}
          \vskip-\topskip \vskip\@tempdimb
        \else
          \vbox to\@tempdimb{\unvbox\@currbox \vskip\z@\@plus.0001fil}
        \fi}%
    \fi
%    \end{macrocode}
% 
% The third and last case is for flushing.  In this case we simply add
% \!\vfil! and \!\penalty! of $-10000$ to make the \colpage{} is immediately
% flushed when it is revisited.  We also let $\cc_c(\pd)=1000$ to mimic
% \TeX's \!\prevdepth! with empty main vertical list again.
% 
%    \begin{macrocode}
  \else
    \global\pcol@prevdepth\@m\p@
    \global\setbox\@currbox\vbox{\unvbox\@currbox \vfil \penalty-\@M}%
  \fi
%    \end{macrocode}
% 
% Finally, we let $\cc_c(\tn)=0$ to inhibit futher addition of top floats
% because we have fixed the space for them\footnote{
% 
% Allowing the addition is tremendously tough even when the \colpage{} has
% sufficiently large space above the \sync{}ation point.},
% 
% and save it and other \cctext{} members into $\cc_c$ by \!\pcol@setcurrcol!.
% 
%    \begin{macrocode}
  \global\@topnum\z@ \pcol@setcurrcol
  \advance\pcol@currcol\@ne}

%    \end{macrocode}
% \end{macro}
% 
% 
% 
% \subsection{Page Flushing}
% \label{sec:imp-sout-flush}
% 
% \begin{macro}{\pcol@output@flush}
% \changes{v1.0}{2011/10/10}
%	{Rename \cs{pcol@makelastpage} as \cs{pcol@makeflushedpage}.}
% \changes{v1.0}{2011/10/10}
%	{Remove unnecessary assignment of \cs{@colht}.}
% 
% The macro \!\pcol@output@flush! is invoked solely from
% \!\pcol@specialoutput! to process the \!\output! request made by
% \!\flushpage!.  We invoke \!\pcol@makeflushedpage! giving it \!\@colht! as
% the height of each \colpage{} to have the shipping-out image of the
% \tpage{} in \!\@outputbox! whose height is then set to be \!\textheight!.
% Then we invoke \!\@outputpage! for shipping out, and then finally
% \!\pcol@freshpage! to have a new page to start new \colpage{}s in it.
% 
%    \begin{macrocode}
%% Special Output Routines: Page Flushing

\def\pcol@output@flush{%
  \pcol@makeflushedpage\@colht
  \setbox\@outputbox\vbox to\textheight{\unvbox\@outputbox}%
  \@outputpage
  \pcol@freshpage}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@output@clear}
% \changes{v1.0}{2011/10/10}
%	{Rename \cs{pcol@makelastpage} as \cs{pcol@makeflushedpage}.}
% \changes{v1.0}{2011/10/10}
%	{Remove unnecessary increment of \cs{pcol@page} and assignment of
%	 \cs{@colht}.}
% 
% The macro \!\pcol@output@clear! is invoked solely from
% \!\pcol@specialoutput! to process the \!\output! request made by
% \!\clearpage!.  The first three and the last lines of this macro are same
% as \!\pcol@output@flush! to flush the \tpage{} and to have a newpage.  In
% the remaining mid part, we invoke \!\pcol@flushfloats! to ship out all
% deferred single-column floats in all columns if any, and then do it for
% multi-column floats by the following invocations enclosed in a group;
% \!\@dblfloatplacement! to set up placement parameters; \!\@makefcolumn!
% with \!\@dbldeferlist! to have a \fpage{} in \!\@outputbox!  if any; and a
% loop of \!\@outputpage! and \!\@makefcolumn! repeated while we have a
% \fpage{}, i.e., $\CSIndex{if@fcolmade}=\true$.
% 
% Note that the mid part is same as that found in \!\@doclearpage! but we
% omit various adjuncts surrouding it as follows;  examination of
% \CSIndex{if@twocolumn} because we should have multiple columns;
% examination of \CSIndex{if@firstcolumn} because we have to clear the page
% immediately even when we are not in the first column;  concatenating
% \!\@dbltoplist! with \!\@dbldeferlist! and clearing it because the author
% believes \!\@dbltoplist! must be empty on the invocation of this macro;
% and letting $\!\@colht!=\!\textheight!$ because \!\pcol@flushfloats! did
% it.
% 
%    \begin{macrocode}
\def\pcol@output@clear{%
  \pcol@makeflushedpage\@colht
  \setbox\@outputbox\vbox to\textheight{\unvbox\@outputbox}%
  \@outputpage
  \pcol@flushfloats
  \begingroup
    \@dblfloatplacement
    \@makefcolumn\@dbldeferlist
    \@whilesw\if@fcolmade\fi{\@outputpage
      \@makefcolumn\@dbldeferlist}%
  \endgroup
  \pcol@freshpage}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@makeflushedpage}
% \changes{v1.0}{2011/10/10}
%	{Renamed from \cs{pcol@makelastpage}.}
% \changes{v1.0}{2011/10/10}
%	{Rename \cs{ifpcol@textonly} as \cs{ifpcol@nospan}.}
% \changes{v1.0}{2011/10/10}
%	{Judge the last page is empty if $V_P\EQ-\infty$ instead of $V_P<0$.}
% 
% The macro $\!\pcol@makeflushedpage!\arg{ht}$ is invoked from
% \!\pcol@output@flush! or \!\pcol@output@clear! with $\arg{ht}=\!\@colht!$
% and from \!\pcol@output@end! with $\arg{ht}=\!\pcol@colht!$.  At first, we
% invoke \!\pcol@output@switch! with setting $\CSIndex{ifpcol@clear}=\true$
% to flush all pages up to $\ptop-1$ and to let $\cc_c(\vb^b)$ have the
% shipping-out image of the main vertical list of each \colpage{} $c$ in
% $\ptop$.  Then after obtaining $p$'s \pctext{} to have
% $\page(\ptop)=\pp^p(\ptop)$, $\!\@colht!=\pp^h(\ptop)$ and
% \CSIndex{ifpcol@nospan} by \!\pcol@getcurrpage!, we build the shipping-out
% image of $\ptop$ in \!\@outputbox! as follows.
% 
% First, if $\CSIndex{ifpcol@nospan}=\false$ to mean the page $\ptop$ has
% \spanning{} in $\pp(\ptop)$, it is put in \!\@outputbox! and is returned
% to \!\@freelist! by \!\@cons!.  Then we examine if $\arg{ht}=-\infty$ to
% mean the macro is invoked from \!\pcol@output@end! (i.e.,
% $\arg{ht}=\!\pcol@colht!$) and all columns are empty.  If so, we do
% nothing but scans $\cc_c(\dl)$ for all $c\In0\C$ by \!\pcol@getcurrcol! to
% let $\CSIndex{if@fcolmade}=\exists c\In0\C:(\cc_c(\dl)\neq())$ to tell it
% to \!\pcol@output@end!.
% 
%    \begin{macrocode}
\def\pcol@makeflushedpage#1{%
  \pcol@cleartrue \pcol@output@switch \pcol@clearfalse
  \pcol@getcurrpinfo\@currbox{\global\c@page}{\global\@colht}\@tempskipa
  \global\@fcolmadefalse
  \setbox\@outputbox\vbox{%
    \ifpcol@nospan\else
      \unvbox\@currbox
      \@cons\@freelist\@currbox
    \fi
    \ifdim#1=-\maxdimen
      \pcol@currcol\z@ \@whilenum\pcol@currcol<\pcol@ncol\do{%
        \pcol@getcurrcol
        \ifx\@deferlist\@empty\else \global\@fcolmadetrue \fi
       \advance\pcol@currcol\@ne}%
%    \end{macrocode}
% 
% Otherwise, i.e., the macro is invoked from \!\pcol@output@flush! or
% \!\pcol@output@clear!, or from \!\pcol@output@end! with
% $\!\pcol@colht!\geq0$ being the size of the tallest column, we put
% $\cc_c(\vb^b)$ for all $c\In0\C$ in a \!\hbox! of \!\textwidth! wide
% separating them by \!\hfil! as follows.  First, if
% $\arg{ht}<\!\@colht!=\pp^h(\ptop)$ to mean the invoker is
% \!\pcol@output@end! and the tallest column is shorter than \!\@colht!, we
% let $\!\@colht!=\arg{ht}$ to let \!\@makecol! build a short \colpage{},
% saving the original value in \!\@pageht! temporarily.  Note that it can
% be $\arg{ht}>\!\@colht!$ due to the additional \!\textfloatsep! below the
% bottom floats but this excess is recovered by the shrink following it.
% Then for each $c$ we obtain $c$'s \cctext{} $\cc_c$ by
% \!\pcol@getcurrcol!, let $\CSIndex{if@fcolmade}=\true$ if
% $\cc_t(\dl)\neq()$, move $\cc_c(\vb^b)$ into \!\box!|255|, and let
% $\footins=\cc_c(\ft)$ by \!\pcol@getcurrfoot! returning it to
% \!\@freelist! if $c$ has footnotes.
% 
% After that we examine if $\cc_c(\tr)=\infty$ to mean we are working on the
% \lpage{} and the \colpage{} is for a \fcolumn{} whose floats can be put as
% top floats, and let $\cc_c(\tr)$ have its original value
% $\!\floatpagefraction!\times\pp^h(\ptop)$ and $\!\topfigrule!=\!\relax!$
% temporarily because the floats are not top ones in reality, if so.  Then
% we also check $\arg{ht}=\pp^h(\ptop)$ to mean the \lpage{} is full size.
% If both of them hold, the floats in $\cc_c(\tl)$ should be (or may be) put
% in the \fpage{} as usual and thus we put them in \!\@outputbox! of
% $\pp^h(\ptop)$ tall, together with \!\vskip! of \!\@fptop! and \!\@fpbot!
% at the top and bottom and that of \!\@fpsep! between floats as
% \!\@makefcolumn! does.  Otherwise we invoke \!\@makecol!\footnote{
% 
% Not \!\pcol@makecol! because the main vertical list has \!\vfil! at its
% tail and the shrink below bottom floats should not be nullified.}
% 
% to have the shipping-out image of the \colpage{} in \!\@outputbox!,
% possibily with the deferred floats in $\cc_c(\tl)$ but without
% \!\topfigrule!.
% 
% Then we put the \!\@outputbox! above in a \!\hbox! of \!\columnwidth! wide
% preceded by \!\pcol@hfil! being \!\relax! for the first column while
% \!\hfil! for others.  Finally, we save \cctext{} especially those for
% float parameters into $\cc_c$ by \!\pcol@setcurrcolnf! because all
% footnotes have been shipped out.
% 
% \changes{v1.0}{2011/10/10}
%	{Let \cs{@colht} be $\langle\mathit{ht}\rangle$ if the former is
%	 less than the latter.}
% \changes{v1.0}{2011/10/10}
%	{Add special care of the float column in the last page.}
% 
%    \begin{macrocode}
    \else
      \hb@xt@\textwidth{%
        \let\pcol@hfil\relax \@pageht\@colht \ifdim#1<\@colht \@colht#1\fi
        \pcol@currcol\z@ \@whilenum\pcol@currcol<\pcol@ncol\do{%
          \pcol@getcurrcol
          \ifx\@deferlist\@empty\else \global\@fcolmadetrue \fi
          \setbox\@cclv\box\@currbox
          \ifvoid\pcol@currfoot\else \@cons\@freelist\pcol@currfoot \fi
          \pcol@getcurrfoot
          \@tempswafalse
          \ifdim\@toproom=\maxdimen
            \global\@toproom\topfraction\@pageht \let\topfigrule\relax
            \ifdim\@colht=\@pageht \@tempswatrue \fi
          \fi
          \if@tempswa
            \setbox\@outputbox\vbox to\@colht{\vskip\@fptop \vskip-\@fpsep
              \def\@elt##1{\vskip\@fpsep\box##1}\@toplist \vskip\@fpbot}%
            \xdef\@freelist{\@freelist\@toplist}\global\@toplist\@empty
          \else \@makecol
          \fi
          \pcol@hfil \hb@xt@\columnwidth{\box\@outputbox\hss}%
          \let\pcol@hfil\hfil
          \pcol@setcurrcolnf
         \advance\pcol@currcol\@ne}}%
    \fi}}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@flushfloats}
% \changes{v1.0}{2011/10/10}
%	{Add reinitialization of \cs{@colht}.}
% 
% The macro \!\pcol@flushfloats! is invoked from \!\pcol@output@clear! and
% \!\pcol@output@end! to flush all deferred single-column floats in each
% column if any.  After letting $\!\@colht!=\!\textheight!$ for
% \fcolumn{}s, we iterate shipping out a page having the \fcolumn{}s while
% $\CSIndex{if@fcolmade}=\exists c\In0\C:(\cc_c(\dl)\neq())$.
% 
% In the loop, we open a \!\vbox! containing a \!\hbox! of \!\textwidth! wide
% to be set into \!\@outputbox!.  For the \!\hbox!, we put an inner \!\hbox!
% of \!\columnwidth! wide preceded by \!\pcol@hfil! being \!\relax! at
% initial or \!\hfil! otherwise, for each $c\In0\C$ by the following
% operations after initializing $\CSIndex{if@tempswa}=f=\false$.  First we
% obtain $c$'s \cctext{} including $\cc_c(\dl)$ by \!\pcol@getcurrcol!
% and pass $\cc_c(\dl)$ to \!\@makefcolumn! to produce a \fcolumn{} in
% \!\@outputbox!  to be put into the inner \!\hbox!.  Then we do $f\gets
% f\lor(\cc_d(\dl)\neq())$ with $\cc_d(\dl)$ shrunk by \!\@makefcolumn! to
% let $f$ have $\exists{}c\In0\C:(\cc_c(\dl)\neq())$ at the end of the inner
% loop for $c$, and then save the \cctext{} into $\cc_c$ by
% \!\pcol@setcurrcolnf! because we have no footntoes in $c$.
% 
% After the end of the inner loop, we move $f$ to \CSIndex{if@fcolmade} for
% the termination check of the outer loop, and invoke \!\@outputpage! to ship
% out the \fpage.
% 
%    \begin{macrocode}
\def\pcol@flushfloats{%
  \global\@colht\textheight
  \@whilesw\if@fcolmade\fi{%
    \setbox\@outputbox\vbox{\hb@xt@\textwidth{%
      \let\pcol@hfil\relax
      \@tempswafalse
      \pcol@currcol\z@ \@whilenum\pcol@currcol<\pcol@ncol\do{%
        \pcol@getcurrcol
        \@makefcolumn\@deferlist
        \pcol@hfil \hb@xt@\columnwidth{\if@fcolmade \box\@outputbox \fi \hss}%
        \ifx\@deferlist\@empty\else \@tempswatrue \fi
        \let\pcol@hfil\hfil
        \pcol@setcurrcolnf
       \advance\pcol@currcol\@ne}%
      \global\@fcolmadefalse
      \if@tempswa \global\@fcolmadetrue \fi}}%
    \@outputpage}}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@freshpage}
% \changes{v1.0}{2011/10/10}
%	{Rename \cs{pcol@maxpage} as \cs{pcol@toppage}.}
% \changes{v1.0}{2011/10/10}
%	{Add save and restore of \cs{@currbox}.}
% \changes{v1.0}{2011/10/10}
%	{Remove unnecessary assignment of \cs{pcol@currcol}.}
% 
% The macro \!\pcol@freshpage! is invoked from \!\pcol@output@flush! and
% \!\pcol@output@clear! to start a new page after column flushing.  At
% first, we let $p=\pbase=\ptop=0$ and $\PP=\emptyset$ because we know no
% pages are kept.  Then we invoke \!\pcol@startpage! to start a new page
% with a \!\def!inition of $\!\pcol@currpage!=|{}|$ to indicate the invoker
% is this macro (i.e., not \!\pcol@opcol!).  Then after keeping \!\@colht!
% in $h=\!\pcol@colht!$, we do the followings for each column $c\In0\C$.
% 
% First we obtain $c$'s \cctext{} in $\cc_c$ by \!\pcol@getcurrcol! but let
% $p=0$ and $\!\@colroom!=h$, which can be modified by $c'<c$, without
% referring to $\cc_c(\vb^p)$ nor $\cc_c(\vb^r)$ because they are obsolete.
% We also save \!\@currbox! to \Midx{\!\pcol@currboxsave!} because it may be
% modified by \!\pcol@opcol! if we make \fcolumn{}s afterward.  Then we invoke
% \!\pcol@getcurrpage! to have the \pctext{} of $p=0$, because it might be
% modified by a column $c'<c$ by producing \fcolumn{}s.  After that and the
% invocation of \!\pcol@floatplacement! for setting float parametners, we
% invoke \!\pcol@startcolumn! for $c$'s \colpage{} at $p=0$, and interate
% \!\pcol@opcol! and \!\pcol@startcolumn! while a \fcolumn{} is made by the
% latter\footnote{
% 
% Each column can have deferred floats on the invocation from
% \!\pcol@output@flush!.}.
% 
% At last in the loop, we restore \!\@currbox! from \!\pcol@currboxsave!,
% let $\cc_c(\vb^b)$ be an empty \!\vbox! because the main vertical list is
% empty, and save the \cctext{} into $\cc_c$ by \!\pcol@setcurrcolnf!
% because of no footnotes obviously, after saving $p$ and \!\@colroom!,
% which might be modified by the \fcolumn{} production, into $\cc_c(\vb^p)$
% and $\cc_c(\vb^r)$.
% 
% After the loop above, finally we invoke \!\pcol@restartcolumn! to return
% to the column in which \!\flushpage! or \!\clearpage! was issued.
% 
%    \begin{macrocode}
\def\pcol@freshpage{%
  \global\pcol@page\z@ \global\pcol@toppage\z@ \global\pcol@basepage\z@
  \global\let\pcol@pages\@empty \global\let\pcol@currpage\@empty
  \pcol@startpage \pcol@colht\@colht
  \pcol@currcol\z@ \@whilenum\pcol@currcol<\pcol@ncol\do{%
    \pcol@getcurrcol \pcol@page\z@ \@colroom\pcol@colht
    \let\pcol@currboxsave\@currbox
    \pcol@getcurrpage
    \pcol@floatplacement
    \pcol@startcolumn
    \@whilesw\if@fcolmade\fi{\pcol@opcol \pcol@startcolumn}%
    \let\@currbox\pcol@currboxsave
    \global\setbox\@currbox\vbox{}%
    \global\count\@currbox\pcol@page \global\dimen\@currbox\@colroom
    \pcol@setcurrcolnf
   \advance\pcol@currcol\@ne}%
  \pcol@restartcolumn}

%    \end{macrocode}
% \end{macro}
% 
% 
% 
% \subsection{Last Page}
% \label{sec:imp-sout-end}
% 
% \begin{macro}{\pcol@output@end}
% \changes{v1.0}{2011/10/10}
%	{Drastically changed to take special care of float columns in the
%	 last page, to deal with the empty last page with and without
%	 deferred floats, and to try to make post-environment float pages.} 
% 
% The macro \!\pcol@output@end! is invoked solely from
% \!\pcol@specialoutput! to process the \!\output! request made by
% \!\endparacol!.  We invoke \!\pcol@makeflushedpage!, after letting
% $\CSIndex{ifpcol@lastpage}=\true$ to notify it of the \lpage{}
% production, giving it $h=\!\pcol@colht!$ in which \!\pcol@sync! sets the
% height of the tallest \colpage{} to have the shipping-out image of the
% \tpage{} in \!\@outputbox!.  Then we process on of the following cases.
% 
% The first case is for $\CSIndex{if@fcolmade}=\true$ to mean
% \!\pcol@makeflushedpage! found columns with deferred floats.  Therefore,
% since we need to have one or more multi-column pages, we ship out the page
% in \!\@outputpage! setting its height to \!\textheight! adding \!\vfil! at
% its tail by \!\@outputpage!, unless the \lpage{} is perfectly empty,
% i.e., $h=-\infty$ and $\CSIndex{ifpcol@nospan}=f_{\it ns}=\true$.  Then we
% invoke \!\pcol@flushfloats! to produce and ship out \fpage{}s.  Finally we
% let $\CSIndex{if@tempswa}=f_{\it sp}=\true$ to remember we will start a
% new page and thus $\!\@pagedp!=\pd=\DP=1000$ to mimic \TeX's \!\prevdepth!
% mechanism.
% 
%    \begin{macrocode}
%% Special Output Routines: Last Page

\def\pcol@output@end{%
  \pcol@lastpagetrue \pcol@makeflushedpage\pcol@colht
  \@tempswafalse
  \if@fcolmade
    \ifdim\pcol@colht>-\maxdimen \@tempswatrue \fi
    \ifpcol@nospan\else \@tempswatrue \fi
    \if@tempswa
      \setbox\@outputbox\vbox to\textheight{\unvbox\@outputbox \vfil}%
      \@outputpage
    \fi
    \pcol@flushfloats
    \@tempswatrue \@pagedp\@m\p@
%    \end{macrocode}
% 
% The second case is for $h=-\infty$ without deferred single-column floats
% to mean all columns in the \lpage{} are empty.  In this case, we examine
% if $\Midx{\!\pcol@firstprevdepth!}=\!\relax!$ to mean we have had at least
% one new page in \env{paracol} environment, i.e., \!\pcol@startpage! have
% been invoked at least once.  If so, we let $f_{\it sp}=\true$ and
% $\pd=1000$ again and put nothing to the main vertical list so that the
% \postenv{} starts from the top of the page.  However, we have to take care
% of the case that $f_{\it ns}=\false$ and thus \!\@outputbox!  has
% \spanning.  If so, we acquire an \!\insert! from \!\@freelist! by
% \!\@next! to let it have the \spanning, i.e., the contents of
% \!\@outputbox! except for the last vertical skip being
% \!\dbltextfloatsep!.  Then the \!\insert! is added to the head of
% \!\@dbldeferlist! with the float placement code 10 to force \LaTeX's float
% placement mechanism to put it to the page to be started shortly.
% 
% On the other hand, $\!\pcol@firstprevdepth!\neq\!\relax!$ means that it has
% $\!\prevdepth!=\pd'$ just before \beginparacol{} in decimal integer
% representation.  Since we have not started any pages in the environment,
% and all columns in the \lpage{} is empty, we have almost nothing in the
% environment.  Note that the environment can have multi-column floats but
% they have not yet put into any pages but are kept in \!\@dbldeferlist!.
% Therefore, the \preenv{} and \postenv{} must be {\em connected} naturally
% and thus we put the \preenv{} kept in \!\@outputbox! to the main vertical
% list by \!\unvbox! and let $\pd=\pd'$\footnote{
% 
% The author of course know this situation is very unlikely but he is
% monomaniac.}.
% 
%    \begin{macrocode}
  \else\ifdim\pcol@colht=-\maxdimen
    \ifx\pcol@firstprevdepth\relax
      \@tempswatrue \@pagedp\@m\p@
      \ifpcol@nospan\else
        \@next\@currbox\@freelist{\global\setbox\@currbox\vbox{
          \unvbox\@outputbox \unskip}}\pcol@ovf
        \count\@currbox10\relax
        {\let\@elt\relax \xdef\@dbldeferlist{\@elt\@currbox\@dbldeferlist}}%
      \fi
    \else \unvbox\@outputbox \@pagedp\pcol@firstprevdepth sp\relax
    \fi
%    \end{macrocode}
% 
% The last case without deferred floats and with some non-empty columns is
% most usual.  In this case, we simply put \!\@outputbox! letting
% $\!\topskip!=0$ because \!\topskip! has already been inserted in
% \colpage{}s or \preenv{} in the box.
% 
%    \begin{macrocode}
  \else
    \topskip\z@ \box\@outputbox
  \fi\fi
%    \end{macrocode}
% 
% The followings are for clean-up and set-up for the \postenv; return all
% $\cc_c(\vb)$ obtained by \!\pcol@getcurrcol! to \!\@freelist!; let
% $\!\pcol@prevdepth!=\pd$ so that it is set to \!\prevdepth! by
% \!\pcol@invokeoutput!; let $\!\@colht!=\!\@colroom!=\!\textheight!$ to
% mean the single-column page does not have any floats so far because those
% produced in or before the environment have already been shipped out, are
% put to the main vertical list packed in \!\@outputbox!, or are in
% \!\@dbldeferlist!.
% 
% As for deferred multi-column floats produced in the environment, including
% those once put in the \lpage{} but returned to the list by the operation
% described above, we move them to \!\@deferlist! because they are now
% single-column floats.  Then we invoke \!\pcol@floatplacement! to
% reinitialize float placement parameters.  Finally, if $f_{\it sp}=\true$,
% we invoke \!\@startcolumn! and then repeat invocations of \!\@opcol! and
% \!\@startcolumn! while \fpage{}s are produced, after letting
% $\CSIndex{ifpcol@lastpage}=\false$ to make \!\@combinefloats! work as
% \LaTeX's original\footnote{
% 
% Letting $\!\pcol@textfloatsep!=\infty$ is done by \!\pcol@floatplacement!.}.
% 
%    \begin{macrocode}
  \pcol@currcol\z@ \@whilenum\pcol@currcol<\pcol@ncol\do{%
    \pcol@getcurrcol \@cons\@freelist\@currbox
   \advance\pcol@currcol\@ne}%
  \global\pcol@prevdepth\@pagedp
  \global\@colht\textheight
  \global\@colroom\textheight
  \global\let\@deferlist\@dbldeferlist \gdef\@dbldeferlist{}%
  \pcol@floatplacement
  \if@tempswa
    \pcol@lastpagefalse
    \@startcolumn \@whilesw\if@fcolmade\fi{\@opcol\@startcolumn}%
  \fi}

%    \end{macrocode}
% \end{macro}
% 
% 
% 
% \section{Starting Environment}
% \label{sec:imp-startenv}
% 
% \begin{macro}{\pcol@invokeoutput}
% \changes{v1.0}{2011/10/10}
%	{Let \cs{pcol@prevdepth} have \cs{prevdepth} directly instead of via
%	 \cs{tempdima}.}
% 
% Before giving the definition of \env{paracol} environment and commands
% used in it, we define the macro $\!\pcol@invokeoutput!\arg{pen}$ invoked
% from them to make an \!\output!-request with \!\penalty! of
% $\arg{pen}=|pcol@op@|{\cdot}f$.  The macro's structure is similar to that
% for the request sequence in \!\end@float! as follows; insert a \!\penalty!
% of $-10004$ to save the main vertical list in \!\@holdpg!; save
% \!\prevdepth!; insert a \!\vbox! to make it sure the following \!\penalty!
% of $\arg{pen}$ is kept even when we are at top of a page; and finally
% restore \!\prevdepth!.
% 
% The difference is in the save\slash restore of \!\prevdepth!.  First, the
% value of the register is saved in our own \!\pcol@prevdepth! instead of
% \!\@tempdima! by a \!\global! assignment so that \!\output!-routine refers
% to it\footnote{
% 
% The assignment is not necessary to be done \!\global!ly but we dare to do
% it to make all assignments to \!\pcol@prevdepth! being \!\global!
% consistently.}.
% 
% Second, the value restored to \!\prevdepth! may be different from that we
% just have saved because \!\output!-routine may update \!\pcol@prevdepth!
% to have, for example, the value saved in $\cc_c(\pd)$ when we left from
% $c$ which we are now restarting.
% 
% The macro is invoked from \!\paracol! ($f=|start|$), \!\pcol@switchcol!
% for \!\switchcolumn! and \csenv{}s ($f=|switch|$), \!\pcol@com@flushpage!
% for \!\flushpage! ($f=|flush|$), \!\pcol@com@clearpage! for \!\clearpage!
% ($f=|clear|$), and \!\endparacol!  ($f=|end|$).
% \SpecialIndex{\pcol@op@start}
% \SpecialIndex{\pcol@op@switch}
% \SpecialIndex{\pcol@op@flush}
% \SpecialIndex{\pcol@op@clear}
% \SpecialIndex{\pcol@op@end}
% 
%    \begin{macrocode}
%% Starting Environment

\def\pcol@invokeoutput#1{%
  \penalty-\@Miv \global\pcol@prevdepth\prevdepth \vbox{}%
  \penalty#1\relax \prevdepth\pcol@prevdepth}

%    \end{macrocode}
% 
% \begin{macro}{\paracol}
% \changes{v1.0}{2011/10/10}
%	{Change the order of operations for sake of clarity.}
% \changes{v1.0}{2011/10/10}
%	{Add the mechanism of inter-environment local counter conservation.}
% \changes{v1.0}{2011/10/10}
%	{Let $\cs{col@number}\EQ1$ instead of $C$ to keep \cs{maketitle} from
%	 producing title with \cs{twocolumn}.}
% \changes{v1.0}{2011/10/10}
%	{Add initialization of \cs{pcol@textfloatsep}, \cs{ifpcol@lastpage},
%	 \cs{pcol@firstprevdepth} and \cs{@combinefloats}.}
% \changes{v1.0}{2011/10/10}
%	{Make API commands environment-local and inhibit nesting of
%	 \texttt{paracol}.} 
% 
% The API macro $\!\paracol!\<\C\>$ is invoked by \beginparacol{} to start
% \Midx{\env{paracol}} environment.  After making it sure to be in vertical
% mode by \CSIndex{par} and letting $\!\pcol@ncol!=\C$, we set up lists for
% counters as follows.  First we obtain $\CC=\!\cl@@ckpt!$ to have all
% counters defined by \!\newcounter! and \counter{page}.  Then we scan
% $\CG=\!\pcol@gcounters!$ applying \!\pcol@remctrelt! to each element to
% have $\CL=\!\pcol@counters!$ for all \lcounter{}s by removing all
% $\cg\in\CG$ from $\CC$, and to move $\clist(\cg)=|\cl@|{\cdot}\cg$ to
% $|\pcol@cl@|{\cdot}\cg$ redefining
% $|\cl@|{\cdot}\cg=\!\pcol@stepcounter!\Arg{\cg}$
% 
% \SpecialArrayIndex{\theta}{\cl@}
% 
% to clear descendant \lcounter{}s of $\cg$, i.e., those in $\clist(\cg)$.
% 
% Next we scan $\CL$ applying \!\pcol@thectrelt! to each element $\cl\in\CL$
% to let $|\pcol@thectr@|{\cdot}\~\cl=|\the|{\cdot}\cl$
% 
% \SpecialArrayIndex{\theta}{\pcol@thectr@}
% \SpecialArrayIndex{\theta}{\the}
% 
% so that the former has the {\em default} \lrep{} of $\cl$.  The macro
% \!\pcol@thectrelt! also lets
% $|\the|{\cdot}\cl=|\pcol@thectr@|{\cdot}\cl{\cdot}0$
% 
% \SpecialArrayIndex{\theta{\cdot}c}{\pcol@thectr@}
% \SpecialArrayIndex{\theta}{\the}
% 
% if the \lrep{} for $\cl$ and $c=0$ has been defined by
% \!\definethecounter!.  This is necessary because in the first visit to the
% leftmost column 0 we will not invoke \!\pcol@switchcol! nor thus scanning
% $\CL$ with \!\pcol@setctrelt! which defines \lrep{}s, unless a \mctext{}
% is specified with \beginparacol.
% 
% Next we give the intial value of $\val_c(\cl)$ for each column $c$ and
% \lcounter{} $\cl\in\CL$ by the followings enclosed in a group.  First we
% scan $\Cc_0$ applying \!\pcol@loadctrelt! to each
% $\cl\in\Cc'_0=\Set{\theta}{\<\theta,\val_0(\theta)\>\in\Cc_0}$ to have
% the value $\val_0(\cl)$ in $|\pcol@ctr@|{\cdot}\cl$
% 
% \SpecialArrayIndex{\theta}{\pcol@ctr@}
% 
% temporarily.  Next we scan $\CL$ to pick \lcounter{}s $\theta$ such that
% $\Uidx\Val(\theta)\neq\val_0(\theta)$ where $\Val(\theta)$ is the value of
% $\theta$ outside \env{paracol} environment, or $\theta\notin\Cc'_0$, to
% let them be listed in \!\@gtempa!.  That is, we pick \lcounter{}s which
% have been updated or defined after the closing of the previous
% \env{paracol}, or everything in $\CL$ at the first \beginparacol{} because
% $\Cc_0=\emptyset$\footnote{
% 
% Undefined in fact.}.
% 
% Finally, we invoke \!\pcol@synccounter! giving it \!\@gtempa! as its
% argument to let $\val_c(\theta)=\Val(\theta)$ for all $c$ and for each
% $\theta$ in \!\@gtempa!.  That is, when \env{paracol} environment appears
% two or more times, the value of a \lcounter{} at the beginning of the
% second or succeeding environment is kept unchanged from that at the end of
% the previous environment, unless it has been updated between them.  Note
% that these scans above are enclosed in a group in order to make
% $|\pcol@ctr@|{\cdot}\cl$
% 
% \SpecialArrayIndex{\theta}{\pcol@ctr@}
% 
% local and thus collected as a garbage at \!\endgroup!.
% 
%    \begin{macrocode}
\def\paracol#1{\par
  \global\pcol@ncol#1\relax
  \global\let\pcol@counters\cl@@ckpt
  \let\@elt\pcol@remctrelt \pcol@gcounters
  \let\@elt\pcol@thectrelt \pcol@counters
  \begingroup
    \let\@elt\pcol@loadctrelt \csname pcol@counters0\endcsname
    \let\@elt\pcol@cmpctrelt \global\let\@gtempa\@empty \pcol@counters
    \pcol@synccounter\@gtempa
  \endgroup
%    \end{macrocode}
% \end{macro}
% 
% Next, we set up a few \LaTeX's typesetting parameters which should have
% appropriate values in the environment.  First we let
% $$
% \!\columnwidth!={\!\textwidth!-(\C-1)\!\columnsep!\over\C}
% $$
% for $\C$-column typesetting and let \!\hsize! and \!\linewidth! have it as
% their initial values.  We then let $\CSIndex{if@twocolumn}=\true$ and
% $\CSIndex{if@firstcolumn}=\true$ so that \textit{float}|*| environments
% work for multi-column floats and \!\marginpar! produces marginal notes
% appropriately.  We also let $\!\col@number!=1$ instead of $\C$ so that
% its (almost surely) sole user \!\maketitle! will not produce the title
% with \!\twocolumn! which cannot be in the environment.
% 
% Then we initialize our own variables;  $\!\pcol@topskip!=\!\topskip!$ for
% the second and succeeding pages;  $\!\pcol@textfloatsep!=\infty$ to mean
% we don't have any \sync{}ation points so far;
% $\CSIndex{ifpcol@lastpage}=\false$ because the \spage{} is not the last so
% far;  and $\!\pcol@firstprevdepth!=\!\prevdepth!$ in decimal integer form
% for the extreme empty case.  We also make the macro
% \Midx{\!\@combinefloats!} \!\let!-equal to our own \!\pcol@combinefloats!
% throughout the environment so that our customization is in effect for any
% invocations including those from \LaTeX's own macros.
% 
%    \begin{macrocode}
  \global\columnwidth\textwidth
  \@tempdima\columnsep \multiply\@tempdima\pcol@ncol
  \advance\@tempdima-\columnsep
  \global\advance\columnwidth-\@tempdima \global\divide\columnwidth\pcol@ncol
  \global\hsize\columnwidth \global\linewidth\columnwidth
  \global\@twocolumntrue \global\@firstcolumntrue \col@number\@ne
  \global\pcol@topskip\topskip
  \global\pcol@textfloatsep\maxdimen
  \pcol@lastpagefalse \xdef\pcol@firstprevdepth{\number\prevdepth}%
  \let\@combinefloats\pcol@combinefloats
%    \end{macrocode}
% 
% Next, we scans the list \!\pcol@localcommands! of $\arg{com}$ being the
% name of commands, e.g., |switchcolumn|, available only in the environment
% or customized for the environment, applying \!\pcol@defcomelt! to each
% $\arg{com}$ to let $|\|\arg{com}=|\pcol@com@|{\cdot}\arg{com}$
% 
% \SpecialArrayMainIndex{\<\string\mathit{com}\>}{\pcol@com@}
% 
% the latter of which is the real implementation of the former.  Note that
% the list does not have all \elocal{} API commands but we omit
% \!\column!(|*|) for \env{column}(|*|) environments because their
% implementations \!\pcol@com@column!(|*|) are modified after the first
% invocation.  Therefore, we \!\def!ine \!\column!(|*|) to have
% \!\pcol@com@column!(|*|) in their bodies\footnote{
% 
% We can do this for other commands instead of adhearing to \cs{let} to
% eliminate the execption, but the author loves to use \cs{let} as much as
% possible.}.
% 
% We also give the first \!\def!initions of
% \!\pcol@com@column!(|*|) to let them do nothing but re\!\def!ine
% themselves by \!\pcol@defcolumn! unless
% \!\pcol@com@column*! is given an optional \mctext{} argument which is
% directly processed by \!\pcol@mctext!, if they appear as the first
% \cswitch{} command\slash environment after \beginparacol.  Then we
% re\!\def!ine \!\paracol! itself so that it will complain of illegal
% nesting by \!\PackageError!.
% 
%    \begin{macrocode}
  \let\@elt\pcol@defcomelt \pcol@localcommands
  \def\column{\pcol@com@column}%
  \@namedef{column*}{\@nameuse{pcol@com@column*}}%
  \global\let\pcol@com@column\pcol@defcolumn
  \global\@namedef{pcol@com@column*}{\pcol@defcolumn
    \@ifnextchar[%]
     \pcol@mctext\relax}%
  \def\paracol##1{\PackageError{paracol}{%
    Environment paracol cannot be nested.}\@eha}%
%    \end{macrocode}
% 
% Then we let \!\output! have our output routine \!\pcol@output! as its sole
% token, and then make \!\output! request with
% $\!\penalty!=\!\pcol@op@start!$ by \!\pcol@invokeoutput! to invoke
% \!\pcol@output@start! for initialization, after letting
% $\!\@elt!=\!\relax!$ to make it sure that any lists can be manipulated
% without unexpected application of a macro to their elements.
% 
%    \begin{macrocode}
  \output{\pcol@output}%
  \let\@elt\relax
  \pcol@invokeoutput\pcol@op@start
%    \end{macrocode}
% 
% Finally, we let $\!\pcol@nextcol!=0$ in case \beginparacol{} has the
% optional argument for \mctext{}, and invoke \!\pcol@mctext! if it has.
% 
%    \begin{macrocode}
  \pcol@nextcol\z@
  \@ifnextchar[%]
    \pcol@mctext\relax}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@localcommands}
% \changes{v1.0}{2011/10/10}
%	{Introduced to make API commands environment-local.}
% 
% The macro \!\pcol@localcommands! is the list of the names of the following
% {\em\Uidx\elocal} API commands (or {\em\Uidx\lcommand{}s} in short) and is
% solely referred to by \!\paracol!.
% 
% \begin{center}\begin{tabular}{llll}
% \!\switchcolumn!&
% \!\endcolumn!(|*|)&
% \!\nthcolumn!(|*|)&\!\endnthcolumn!(|*|)\\
% \!\leftcolumn!(|*|)&\!\endleftcolumn!(|*|)&
% \!\rightcolumn!(|*|)&\!\endrightcolumn!(|*|)\\
% \!\flushpage!&
% \!\clearpage!&
% \!\synccounter!&
% \!\syncallcounters!
% \end{tabular}\end{center}
% 
% Note that we omit \!\column!(|*|) from the list as discussed in the
% description of \!\paracol!.
% 
%    \begin{macrocode}
\def\pcol@localcommands{%
  \@elt{switchcolumn}%
  \@elt{endcolumn}\@elt{endcolumn*}%
  \@elt{nthcolumn}\@elt{endnthcolumn}\@elt{nthcolumn*}\@elt{endnthcolumn*}%
  \@elt{leftcolumn}\@elt{endleftcolumn}\@elt{leftcolumn*}\@elt{endleftcolumn*}%
  \@elt{rightcolumn}\@elt{endrightcolumn}%
    \@elt{rightcolumn*}\@elt{endrightcolumn*}%
  \@elt{flushpage}\@elt{clearpage}%
  \@elt{synccounter}\@elt{syncallcounters}}
%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@defcomelt}
% \changes{v1.0}{2011/10/10}
%	{Introduced to make API commands environment-local.}
% 
% The macro \!\pcol@defcomelt! is invoked solely from \!\paracol! to be
% applied to each element $\arg{com}$ in \!\pcol@localcommands!.  Two
% lengthy \!\let!s with \!\expandafter!s are for doing
% $\!\let!|\|\arg{com}|=\pcol@com@|{\cdot}\arg{com}$ to bind the \elocal{}
% API command $|\|\arg{com}$ and its implementation
% $|\pcol@com@|{\cdot}\arg{com}$.
% 
% \SpecialArrayIndex{\<\string\mathit{com}\>}{\pcol@com@}
% 
%    \begin{macrocode}
\def\pcol@defcomelt#1{%
  \expandafter\let\expandafter\reserved@a\csname pcol@com@#1\endcsname
  \expandafter\let\csname #1\endcsname\reserved@a}

%    \end{macrocode}
% \end{macro}
% 
% 
% 
% \section{Counter Operations}
% \label{sec:imp-counter}
% 
% \begin{macro}{\globalcounter}
% \begin{macro}{\pcol@gcounters}
% The API macro $\!\globalcounter!\arg{ctr}$ defines that $\arg{ctr}$ is a
% \gcounter, and thus add it to $\CG=\Midx{\!\pcol@gcounters!}$, which has
% \counter{page} at initial.  Note that initial definition of
% \!\pcol@gcounters! is done by \!\gdef! just for cosistent \!\global!
% assignments to it.
% 
%    \begin{macrocode}
%% Counter Opearations

\def\globalcounter#1{\@cons\pcol@gcounters{{#1}}}
\gdef\pcol@gcounters{\@elt{page}}
%    \end{macrocode}
% \end{macro}\end{macro}
% 
% \begin{macro}{\pcol@remctrelt}
% \begin{macro}{\pcol@iremctrelt}
% The macro $\!\pcol@remctrelt!\<\cg\>$ is invoked solely from \!\paracol!
% and is applied to each \gcounter{} $\cg\in\CG$ to remove it from
% $\CC=\!\pcol@counters!$ in which we have $\CL$ finally.  The macro is also
% move $|\cl@|{\cdot}\cg=\clist(\cg)$
% 
% \SpecialArrayIndex{\theta}{\cl@}
% 
% to $|\pcol@cl@|{\cdot}\cg$
% 
% \SpecialArrayMainIndex{\theta}{\pcol@cl@}
% 
% to keep the list of the descendant \lcounter{}s of $\cg$ in it, and then
% re\!\def!ine $|\cl@|{\cdot}\cg=\!\pcol@stepcounter!\Arg{\cg}$
% 
% \SpecialArrayMainIndex{\theta}{\cl@}
% 
% so that it is invoked on $\!\stepcounter!\Arg{\cg}$ to let $\val_c(\cl)=0$
% for all $c\In0\C$ and $\cl\in\clist(\cg)$, if $\cg\neq\counter{page}$.
% These operations are performed by a lengthy sequence with many occurences
% of \!\expandafter!, \!\csname! and \!\endcsname! but the sequence is
% equivalent to the following.
% 
% \begin{quote}
% $\!\let!|\pcol@cl@|{\cdot}\cg|=\cl@|{\cdot}\cg$\\
% $\CSIndex{ifx}|\c@|{\cdot}\cg\!\c@page!|\else |
%     |\def\cl@|{\cdot}\cg|{|\!\pcol@stepcounter!|{|\cg|}}\fi|$
% \end{quote}
% 
% As for the removal of $\cg$ from $\CC$, we do $\CC'\gets\CC$,
% $\CC\gets\emptyset$, and then apply \!\pcol@iremctrelt! to each
% $\theta\in\CC'$ to let $\CC\gets\CC\cup\{\theta\}$ by \!\@cons! if
% $\theta\neq\cg$.
% 
%    \begin{macrocode}
\def\pcol@remctrelt#1{%
  \expandafter\let\expandafter\reserved@a\csname cl@#1\endcsname
  \expandafter\let\csname pcol@cl@#1\endcsname\reserved@a
  \expandafter\ifx\csname c@#1\endcsname\c@page\else
    \@namedef{cl@#1}{\pcol@stepcounter{#1}}%
  \fi
  \def\reserved@a{#1}\let\reserved@b\pcol@counters
  \global\let\pcol@counters\@empty
  {\let\@elt\pcol@iremctrelt \reserved@b}}
\def\pcol@iremctrelt#1{%
  \def\reserved@b{#1}%
  \ifx\reserved@a\reserved@b\else \@cons\pcol@counters{{#1}}\fi}

%    \end{macrocode}
% \end{macro}\end{macro}
% 
% \begin{macro}{\definethecounter}
% The API macro $\!\definethecounter!\<\cl\>\<c\>\arg{rep}$ define the
% \lrep{} $\arg{rep}$ for a \lcounter{} $\cl$ in a column $c$.  It
% \!\def!ines $|\pcol@thectr@|{\cdot}\cl{\cdot}c$
% 
% \SpecialArrayMainIndex{\theta{\cdot}c}{\pcol@thectr@}
% 
% to have $\arg{rep}$ in its  body.
% 
%    \begin{macrocode}
\def\definethecounter#1#2#3{\@namedef{pcol@thectr@#1#2}{#3}}
%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@thectrelt}
% The macro $\!\pcol@thectrelt!\<\cl\>$ is invoked solely in \!\paracol!
% and is applied to each $\cl\in\CL$ to define its \lrep{} of
% default and that of the leftmost column 0.  It performs a lengthy sequence
% with many occurences of \!\expandafter!, \!\csname! and \!\endcsname! but
% the sequence is equivalent to the followings.
% 
% \begin{quote}
% $\!\let!|\pcol@thectr@|{\cdot}\cl|=\the|{\cdot}\cl$\\
% $\CSIndex{ifx}|\pcol@thectr@|{\cdot}\cl{\cdot}0\!\relax!|\else |
%     \!\let!|\the|{\cdot}\cl|=\pcol@thectr@|{\cdot}\cl{\cdot}0| \fi|$
% \end{quote}
% 
% \SpecialArrayMainIndex{\theta}{\pcol@thectr@}
% \SpecialArrayIndex{\theta{\cdot}c}{\pcol@thectr@}
% \SpecialArrayMainIndex{\theta}{\the}
% 
%    \begin{macrocode}
\def\pcol@thectrelt#1{%
  \expandafter\let\expandafter\reserved@a\csname the#1\endcsname
  \expandafter\let\csname pcol@thectr@#1\endcsname\reserved@a
  \expandafter\let\expandafter\reserved@a\csname pcol@thectr@#10\endcsname
  \ifx\reserved@a\relax\else
    \expandafter\let\csname the#1\endcsname\reserved@a
  \fi}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@loadctrelt}
% \changes{v1.0}{2011/10/10}
%	{Introduced for inter-environment local counter conservation.}
% \begin{macro}{\pcol@storecounters}
% \changes{v1.0}{2011/10/10}
%	{Introduced for inter-environment local counter conservation.}
% \begin{macro}{\pcol@storectrelt}
% \changes{v1.0}{2011/10/10}
%	{Introduced for inter-environment local counter conservation.}
% 
% The macro $\!\pcol@loadctrelt!\<\cl\>\<\val_c(\cl)\>$ is invoked from
% \!\paracol! and \!\pcol@synccounter! and is applied to each element
% $\<\cl,\val_c(\cl)\>\in\Cc_c$ for a column $c$ to define a macro
% $|\pcol@ctr@|{\cdot}\cl=v(\cl)$
% 
% \SpecialArrayMainIndex{\theta}{\pcol@ctr@}
% 
% having $\val_c(\cl)$ in its body for a temporary use.  This macro or its
% redefined version is then referred to by $\!\pcol@cmpctrelt!\<\cl\>$ or
% $\!\pcol@storectrelt!\<\cl\>$.  The latter is invoked from
% \!\pcol@storecounters! via \!\pcol@sscounters! to add $\<\cl,v(\cl)\>$ to
% \!\@gtempa! by \!\@cons! to rebuild $\CC_c$ for a column $c$ in
% \!\@gtempa!.
% 
% The macro \!\pcol@storecounters! is invoked solely from
% $\!\pcol@synccounter!\<\theta\>$ to update a \lcounter{} $\theta$ with
% $\Val(\theta)$ for \csync.  That is, \!\pcol@storecounters! is used to add
% $\<\cl,v(\cl)\>$ to \!\@gtempa! for all $\cl\in\CL$ by \!\pcol@sscounters!
% giving it \!\pcol@storectrelt! as its argument, where $v(\cl)$ is modified
% if $\cl=\theta$ or unmodifed otherwise after it is defined by
% \!\pcol@loadctrelt!.
% 
%    \begin{macrocode}
\def\pcol@loadctrelt#1#2{\@namedef{pcol@ctr@#1}{#2}}
\def\pcol@storecounters{\pcol@sscounters\pcol@storectrelt}
\def\pcol@storectrelt#1{\@cons\@gtempa{{#1}{\@nameuse{pcol@ctr@#1}}}}
%    \end{macrocode}
% \end{macro}\end{macro}\end{macro}
% 
% \begin{macro}{\pcol@savecounters}
% \changes{v1.0}{2011/10/10}
%	{Move the body to \cs{pcol@sscounters}.}
% 
% \begin{macro}{\pcol@savectrelt}
% The macro \!\pcol@savecounters! is invoked from
% \!\pcol@com@syncallcounters!, \!\pcol@stepcounter! and \!\pcol@switchcol!
% to let $\CC_c$ for a column $c$ have the list of $\<\cl,\val_c(\cl)\>$
% where $\val_c(\cl)$ is the value of $|\c@|{\cdot}\cl$ to be saved in
% the list.
% 
% \SpecialArrayIndex{\theta}{\c@}
% 
% It does this operation invoking \!\pcol@sscounters! giving it
% \!\pcol@savectrelt! as its argument.
% 
% The macro $\!\pcol@savectrelt!\<\cl\>$ adds $\<\cl,\val_c(\cl)\>$ to
% \!\@gtempa! by \!\@cons! to rebuild $\CC_c$ for a column $c$ in
% \!\@gtempa!.
% 
%    \begin{macrocode}
\def\pcol@savecounters{\pcol@sscounters\pcol@savectrelt}
\def\pcol@savectrelt#1{\@cons\@gtempa{{#1}{\number\csname c@#1\endcsname}}}
%    \end{macrocode}
% \end{macro}\end{macro}
% 
% \begin{macro}{\pcol@sscounters}
% \changes{v1.0}{2011/10/10}
%	{Introduced to implement the common operations of
%	 \cs{pcol@storecounters} and \cs{pcol@savecounters}.}
% 
% The macro $\!\pcol@sscounters!\arg{elt}$ is invoked from
% \!\pcol@storecounters! with $\arg{elt}=\!\pcol@storectrelt!$ or
% \!\pcol@savecounters! with $\arg{elt}=\!\pcol@savectrelt!$ to build
% $\CC_c=|\pcol@counters|{\cdot}c$ for a column $c$.
% 
% \SpecialArrayMainIndex{c}{\pcol@counters}
% 
% To do that, it lets $\!\@gtempa!=()$ and then apply $\arg{elt}$ to all
% $\cl\in\CL=\!\pcol@counters!$ to have updated $\CC_c$ in \!\@gtempa!.
% Then finally, \!\@gtempa! is moved into $\CC_c$ by \!\xdef!\footnote{
% 
% It can be done by \cs{global}\cs{let} more efficiently but it is lengthy
% due to two \cs{expandafter}.}.
% 
%    \begin{macrocode}
\def\pcol@sscounters#1{\begingroup
  \global\let\@gtempa\@empty
  \let\@elt#1\relax \pcol@counters
  \let\@elt\relax
  \expandafter\xdef\csname pcol@counters\number\pcol@currcol\endcsname{%
    \@gtempa}%
  \endgroup}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@cmpctrelt}
% \changes{v1.0}{2011/10/10}
%	{Introduced for inter-environment local counter conservation.}
% 
% The macro $\!\pcol@cmpctrelt!\<\theta\>$ is invoked solely from
% \!\paracol!  and is applied to each $\theta\in\CC$ to examine if
% $\val_0(\theta)=\Val(\theta)$ where $\val_0(\theta)$ is in
% $|\pcol@ctr@|{\cdot}\theta$.
% 
% \SpecialArrayIndex{\theta}{\pcol@ctr@}
% 
% If the examination fails including due to that $|\pcol@ctr@|{\cdot}\theta$
% 
% \SpecialArrayIndex{\theta}{\pcol@ctr@}
% 
% is undefined, we add $\theta$ to the list \!\@gtempa! by \!\@cons!.
% 
%    \begin{macrocode}
\def\pcol@cmpctrelt#1{\@tempswafalse \@tempcnta\@nameuse{c@#1}%
  \expandafter\ifx\csname pcol@ctr@#1\endcsname\relax \@tempswatrue
  \else\ifnum\@nameuse{pcol@ctr@#1}=\@tempcnta\else \@tempswatrue
  \fi\fi
  \if@tempswa \@cons\@gtempa{{#1}}\fi}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\synccounter}
% \changes{v1.0}{2011/10/10}
%	{Introduced as an environment-local API command.}
% \begin{macro}{\pcol@com@synccounter}
% \changes{v1.0}{2011/10/10}
%	{Introduced for the implementation of the new API command
%	 \cs{synccounter}.} 
% 
% The macro $\!\pcol@com@synccounter!\<\theta\>$, the implementation of the
% \elocal{} API macro \!\synccounter!, lets $\val_c(\theta)=\Val(\theta)$
% for all $c\In0\C$.  That is, the value of the counter $\theta$ is {\em
% broadcasted} to all columns for the {\em\Uidx\csync} of $\theta$.  This
% broadcast is done by \!\pcol@synccounter! with an argument
% $\!\@elt!|{|\theta|}|$ so that it works only on $\theta$.
% 
%    \begin{macrocode}
\def\pcol@com@synccounter#1{\pcol@synccounter{\@elt{#1}}}
%    \end{macrocode}
% \end{macro}\end{macro}
% 
% \begin{macro}{\pcol@synccounter}
% \changes{v1.0}{2011/10/10}
%	{Introduced for \cs{synccounter} and inter-environment local counter
%	 conservation.}
% \begin{macro}{\pcol@syncctrelt}
% \changes{v1.0}{2011/10/10}
%	{Introduced for \cs{synccounter} and inter-environment local counter
%	 conservation.}
% 
% The macro $\!\pcol@synccounter!\arg{lst}$ is invoked from \!\paracol! with
% $\arg{lst}=\!\@gtempa!$ and from $\!\pcol@com@synccounter!\arg{ctr}$ with
% $\arg{lst}=\!\@elt!\Arg{ctr}$, to let $\val_c(\theta)=\Val(\theta)$ for
% all $c\In0\C$ and all $\theta$ in $\arg{lst}$.  To do that, at first we
% move $\arg{lst}$ into \!\reserved@a! in order to make \!\@gtempa! free so
% that it can be used in \!\pcol@storecounters!.  Next, for each $c\In0\C$,
% we let $v(\cl)=\val_c(\cl)$ by applying \!\pcol@loadctrelt! to all
% $\<\cl,\val_c(\cl)\>\in\Cc_c$, then scan $\arg{lst}$ applying
% $\!\pcol@syncctrelt!\<\theta\>$ for each $\theta$ in $\arg{lst}$ to let
% $v(\theta)=\Val(\theta)$, and finally store all $v(\cl)$ back to $\Cc_c$
% by \!\pcol@storecounters!, where $v(\theta)$ is
% $|\pcol@ctr@|{\cdot}\theta$.
% 
% \SpecialArrayIndex{\theta}{\pcol@ctr@}
% 
%    \begin{macrocode}
\def\pcol@synccounter#1{{%
  \let\@elt\relax \edef\reserved@a{#1}%
  \pcol@currcol\z@ \@whilenum\pcol@currcol<\pcol@ncol\do{%
    \let\@elt\pcol@loadctrelt \@nameuse{pcol@counters\number\pcol@currcol}%
    \let\@elt\pcol@syncctrelt\reserved@a
    \pcol@storecounters
    \advance\pcol@currcol\@ne}}}
\def\pcol@syncctrelt#1{%
    \expandafter\edef\csname pcol@ctr@#1\endcsname{\number\@nameuse{c@#1}}}

%    \end{macrocode}
% \end{macro}\end{macro}
% 
% \begin{macro}{\syncallcounters}
% \changes{v1.0}{2011/10/10}
%	{Introduced as an environment-local API command.}
% \begin{macro}{\pcol@com@syncallcounters}
% \changes{v1.0}{2011/10/10}
%	{Introduced for the implementation of the new API command
%	 \cs{syncallcounters}.} 
% 
% The macro \!\pcol@com@syncallcounters!, the implementation of the
% \elocal{} API macro \!\syncallcounters! makes all \lcounter{}s in all
% columns have the value in the current column.  That is, for each
% $c\In0\C$, we invoke \!\pcol@savecounters! to let $\val_c(\cl)=\Val(\cl)$
% for all $\cl\in\CL$.
% 
%    \begin{macrocode}
\def\pcol@com@syncallcounters{{%
  \pcol@currcol\z@ \@whilenum\pcol@currcol<\pcol@ncol\do{%
    \pcol@savecounters \advance\pcol@currcol\@ne}}}

%    \end{macrocode}
% \end{macro}\end{macro}
% 
% \begin{macro}{\pcol@setctrelt}
% \changes{v1.0}{2011/10/10}
%	{Replace \cs{setcounter} with direct assignment with \cs{csname} and
%	 \cs{endcsname}}
% 
% The macro $\!\pcol@setctrelt!\<\cl\>\<\val_c(\cl)\>$ is solely inovked
% from \!\pcol@switchcol! to swich to a column $c$ and is applied to each
% $\<\cl,\val_c(\cl)\>\in\Cc_c$ to let $\Val(\cl)=\val_c(\cl)$ \!\global!ly.
% It also define the \lrep{} of $\cl$, being $|\the|{\cdot}\cl$,
% 
% \SpecialArrayIndex{\theta}{\the}
% 
% to be $|\pcol@thectr@|{\cdot}\cl{\cdot}c$
% 
% \SpecialArrayIndex{\theta{\cdot}c}{\pcol@thectr@}
% 
% if it is defined, or otherwise to be $|\pcol@thectr@|{\cdot}\cl$ which keeps
% the original $|\the|{\cdot}\cl$.
% 
% \SpecialArrayIndex{\theta}{\the}
% 
% This \lrep{} definition is done by a lengthy sequence with many occurences
% of \!\expandafter!, \!\csname! and \!\endcsname!, but it is equivalent to
% the followings.
% 
% \begin{quote}
% $\CSIndex{ifx}|\pcol@thectr@|{\cdot}\cl{\cdot}c\!\relax!| |
%     \!\let!|\the|{\cdot}\cl|=\pcol@thectr@|{\cdot}\cl$\\
% $|\else |\!\let!|\the|{\cdot}\cl|=\pcol@thectr@|{\cdot}\cl{\cdot}c$\\
% |\fi|
% \end{quote}
% % 
%    \begin{macrocode}
\def\pcol@setctrelt#1#2{%
  \global\csname c@#1\endcsname#2\relax
  \expandafter\ifx\csname pcol@thectr@#1\number\pcol@currcol\endcsname\relax
    \expandafter\let\expandafter\reserved@a\csname pcol@thectr@#1\endcsname
  \else
    \expandafter\let\expandafter\reserved@a
      \csname pcol@thectr@#1\number\pcol@currcol\endcsname
  \fi
  \expandafter\let\csname the#1\endcsname\reserved@a}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@stepcounter}
% \changes{v1.0}{2011/10/10}
%	{Change the order of operations.}
% \changes{v1.0}{2011/10/10}
%	{Replace \cs{csname}/\cs{endcsname} with \cs{@nameuse}.}
% 
% \begin{macro}{\pcol@stpldelt}
% \begin{macro}{\pcol@stpclelt}
% The macro $\!\pcol@stepcounter!\<\cg\>$ is invoked from
% $\!\stepcounter!\<\cg\>$ for a \gcounter{} $\cg$ because
% $|\cl@|{\cdot}\cg$
% 
% \SpecialArrayIndex{\theta}{\cl@}
% 
% is modified by \!\pcol@remctrelt! so as to invoke this macro to zero-clear
% \lcounter{}s $\theta\in\clist(\cg)$.  To do that, we do the followings in
% a group for each $c\In0\C$.  First we apply
% $\!\pcol@stpldelt!\<\cl\>\<\val_c(\cl)\>$ to each
% $\<\cl,\val_c(\cl)\>\in\Cc_c$ to let $\Val(\cl)=\val_c(\cl)$ locally.
% Then we apply $\!\pcol@stpclelt!\<\theta\>$ to each $\theta\in\clist(\cg)$
% to let $\Val(\theta)=0$.  Finally, we invoke \!\pcol@savecounters! to let
% $\val_c(\cl)=\Val(\cl)$ for all $\cl\in\CL$ to reflect the zero-clear of
% $\theta\in\clist(\cg)$.
% 
% After the operations above, we apply $\!\@stpelt!\<\theta\>$ to each
% $\theta\in\clist(\cg)$ for \!\global! zero-clearing.
% 
%    \begin{macrocode}
\def\pcol@stepcounter#1{\begingroup
  \pcol@currcol\z@ \@whilenum\pcol@currcol<\pcol@ncol\do{%
    \let\@elt\pcol@stpldelt \@nameuse{pcol@counters\number\pcol@currcol}%
    \let\@elt\pcol@stpclelt \@nameuse{pcol@cl@#1}%
    \pcol@savecounters
   \advance\pcol@currcol\@ne}%
  \endgroup
  \let\@elt\@stpelt \@nameuse{pcol@cl@#1}}
\def\pcol@stpldelt#1#2{\csname c@#1\endcsname#2\relax}
\def\pcol@stpclelt#1{\csname c@#1\endcsname\z@}

%    \end{macrocode}
% \end{macro}\end{macro}\end{macro}
% 
% 
% 
% \section{Column-Switching Commands and Environments}
% \label{sec:imp-switch}
% 
% \begin{macro}{\pcol@par}
% \changes{v1.0}{2011/10/10}
%	{Introduced for \cs{par}-if-necessary operation.}
% 
% Before giving the definition of \cswitch{} commands and environments, we
% define a commonly used macro \!\pcol@par!, which do \CSIndex{par} if
% necessary, i.e., we are not in vertical mode.  The reason why we don't
% simply do \CSIndex{par} is that it may have some definition different from
% \!\@@par! and thus an incautious repetition of \CSIndex{par} may cause
% undesirable results.  This macro is used in \!\pcol@com@switchcolumn!,
% \!\pcol@mctext!, \!\pcol@com@endcolumn!, \!\pcol@com@flushpage!,
% \!\pcol@com@clearpage! and \!\endparacol!.
% 
%    \begin{macrocode}
%% Column-Switching Commands and Environments

\def\pcol@par{\ifvmode\else \par \fi}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\switchcolumn}
% \changes{v1.0}{2011/10/10}
%	{Made \cs{let}-equal to \cs{pcol@com@switchcolumn} for localization.}
% \begin{macro}{\pcol@com@switchcolumn}
% \changes{v1.0}{2011/10/10}
%	{Introduced as the implementation of \cs{switchcolumn}.}
% \changes{v1.0}{2011/10/10}
%	{Add \cs{pcol@defcolumn} to clarify the behavior of \texttt{column}.}
% \begin{macro}{\pcol@switchcolumn}
% \changes{v1.0}{2011/10/10}
%	{Add the check of $d\geq0$.}
% 
% \begin{macro}{\pcol@iswitchcolumn}
% The macro $\!\pcol@com@switchcolumn!|[|d|]|$, the implementation of the
% \elocal{} API macro \!\switchcolumn!, switches to the column $d$ if provided
% through its optional argument, or to $d=(c+1)\bmod\C$ otherwise where $c$
% is the ordinal of the current column.  After making it sure to be in
% vertical mode by \!\pcol@par!, it invokes \!\pcol@defcolumn! to give
% \!\pcol@com@column!(|*|) their
% \!\def!initions for occurences not as the very first \cswitch{} command
% nor environment of \env{paracol} environment.  Then, after calculating
% $d=(c+1)\bmod\C$, this macro simply invokes
% $\!\pcol@switchcol!|[|d|]|$ with or without the calculated $d$
% depending on the existance of the optional argument delimitor `|[|'.
% 
% The macro $\!\pcol@switchcol!|[|d|]|$ lets $\!\pcol@nextcol!=d$ and
% confirms $0\leq d<\C$ or abort the execution by \!\PackageError! if it
% does not hold.  Then it invokes \!\pcol@iswitchcolumn! if
% $\!\switchcolumn!|[|d|]|$ is followed by a `|*|', or \!\pcol@switchcol!
% othewise.
% 
% The macro $\!\pcol@iswitchcolumn!|[|\arg{txt}|]|$ invokes
% $\!\pcol@mctext!|[|\arg{txt}|]|$ if the optional argument is provided, or
% \!\pcol@switchcol! otherwise, after letting $\CSIndex{ifpcol@sync}=\true$
% for \exsync{}.
% 
%    \begin{macrocode}
\def\pcol@com@switchcolumn{\pcol@par
  \pcol@defcolumn
  \@tempcnta\pcol@currcol \advance\@tempcnta\@ne
  \ifnum\@tempcnta<\pcol@ncol\else \@tempcnta\z@ \fi
  \@ifnextchar[%]
    \pcol@switchcolumn{\pcol@switchcolumn[\@tempcnta]}}
\def\pcol@switchcolumn[#1]{%
  \pcol@nextcol#1\relax
  \@tempswafalse
  \ifnum#1<\z@ \@tempswatrue \fi
  \ifnum#1<\pcol@ncol\else \@tempswatrue \fi
  \if@tempswa
    \PackageError{paracol}{%
      Column number \number#1 must be less than\number\pcol@ncol}\@eha
    \pcol@nextcol\z@
  \fi
  \@ifstar\pcol@iswitchcolumn\pcol@switchcol}
\def\pcol@iswitchcolumn{%
  \global\pcol@synctrue
  \@ifnextchar[%]
    \pcol@mctext\pcol@switchcol}

%    \end{macrocode}
% \end{macro}\end{macro}\end{macro}\end{macro}
% 
% \begin{macro}{\pcol@mctext}
% \changes{v1.0}{2011/10/10}
%	{Made \cs{long} to allow \cs{par} in its argument.}
% \changes{v1.0}{2011/10/10}
%	{Replace \cs{par} with \cs{pcol@par}.}
% \changes{v1.0}{2011/10/10}
%	{Add $\cs{ifpcol@mctexttrue}\EQ\mathit{true}$ for restriction of the
%	 broadcast of \cs{if@nobreak} and \cs{everypar}.}
% 
% The macro $\!\pcol@mctext!|[|\arg{txt}|]|$ is invoked from \!\paracol! and
% \!\pcol@iswitchcolumn! to put a \Uidx\mctext{} $\arg{txt}$ given as the
% optional argument of the former and \!\switchcolumn!|*|.  The macro has
% \!\long!  attribute because the \mctext{} may have \CSIndex{par}.  Since
% the text is put in the column 0 always, we switch to the column by
% \!\pcol@switchcol! turning $\CSIndex{ifpcol@sync}=\true$ to set a
% \sync{}ation point above the text, afetr saving the target column
% $d=\!\pcol@nextcol!$ in \!\@tempcnta!.  Then the text is put in a group in
% which we let $\!\hsize!=\!\textwidth!$ to let \mctext{} span across all
% columns, and $\!\col@number!=1$ to ensure again that \!\maketitle!
% produces a title without \!\twocolumn! if it is in the \mctext.  Then,
% after invoking \!\pcol@par! to ensure to be in vertical mode, we let
% $\CSIndex{pcol@mctext}=\true$ so that \!\pcol@output@switch!  broadcasts
% $\CSIndex{if@nobreak}$ if true and \!\everypar! which is \!\global!ized by
% a sequence with three \!\expandafter!.  Finally after closing the group,
% we let $\!\pcol@nextcol!=d$ and $\CSIndex{pcol@sync}=\true$ to set another
% \sync{}ation point below the \mctext, and then invoke \!\pcol@switchcol!
% to switch the coloumn $d$.
% 
%    \begin{macrocode}
\long\def\pcol@mctext[#1]{%
  \@tempcnta\pcol@nextcol
  \global\pcol@synctrue \pcol@nextcol\z@
  \pcol@switchcol
  \begingroup
    \hsize\textwidth \col@number\@ne #1\pcol@par
    \global\pcol@mctexttrue
    \expandafter\global\expandafter\everypar\expandafter{\the\everypar}%
  \endgroup
  \pcol@nextcol\@tempcnta \global\pcol@synctrue \pcol@switchcol}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@switchcol}
% \changes{v1.0}{2011/10/10}
%	{Add \cs{pcol@aconly} for disabling \cs{addcontentsline}.}
% 
% The macro \!\pcol@switchcol! is invoked from \!\pcol@switchcolumn!,
% \!\pcol@iswitchcolumn!, \!\pcol@mctext! and \!\endparacol! to switch the
% column $d=\!\pcol@nextcol!$.  First, we save \lcounter{}s in the current
% column $c$ into $\Cc_c$ by \!\pcol@savecounters!.  Next, we make an
% \!\output! request with $\!\penalty!=\!\pcol@op@switch!$ to invoke
% \!\pcol@output@switch! by \!\pcol@invokeoutput! to switch to the column
% $d$.
% 
% Then we let $\CSIndex{if@firstcolumn}$ be $\true$ or $\false$ according to
% $d=0$ or not respectively, so that \!\marginpar! produces marginal notes
% appropriately.  Then we scan $\Cc_d$ applying \!\pcol@setctrelt! to each
% $\<\cl,\val_d(\cl)\>\in\Cc_d$ to let $\Val(\cl)=\val_d(\cl)$.  We also
% scan $\T=\!\pcol@aconly!$ applying \!\pcol@aconlyelt! to each
% $\<t_c,c\>\in T$ to inhibit \!\addcontentsline! to the contents file of
% type $t_d$ as specified so by $\!\addcontentsonly!\arg{t_d}\arg{d}$.
% Finally, we let $\!\@elt!=\!\relax!$ to make it sure that any lists can be
% manipulated without unexpected application of a macro to their elements.
% 
%    \begin{macrocode}
\def\pcol@switchcol{%
  \pcol@savecounters
  \pcol@invokeoutput\pcol@op@switch
  \ifnum\pcol@currcol=\z@ \global\@firstcolumntrue
  \else                   \global\@firstcolumnfalse
  \fi
  \let\@elt\pcol@setctrelt
  \csname pcol@counters\number\pcol@currcol\endcsname
  \let\@elt\pcol@aconlyelt \pcol@aconly
  \let\@elt\relax}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\column}
% \changes{v1.0}{2011/10/10}
%	{Made \cs{let}-equal to \cs{pcol@com@column} for localization.}
% \begin{macro}{\column*}
% \changes{v1.0}{2011/10/10}
%	{Made \cs{let}-equal to \cs{pcol@com@column*} for localization.}
% \begin{macro}{\pcol@com@column}
% \changes{v1.0}{2011/10/10}
%	{Introduced as the implemenatation of \cs{column}.}
% \begin{macro}{\pcol@com@column*}
% \changes{v1.0}{2011/10/10}
%	{Introduced as the implemenatation of \cs{column*}.}
% \begin{macro}{\pcol@defcolumn}
% \changes{v1.0}{2011/10/10}
%	{Replace \cs{column} with \cs{pcol@com@column} and \cs{switchcolumn}
%	 with \cs{pcol@switchenv}.}
% 
% The macros \!\pcol@com@column!(|*|), the implementations of the \elocal{}
% API commands \!\column!(*), starts the environment \Midx{\env{column}}.
% Basically, the macros do \!\switchcolumn!\~(|*|), but if the environment
% starts just after \beginparacol{} the macro have to switch to the column
% 0.  Therefore, the definitions for this very-beginning appearance are
% given in \!\paracol! to do (almost) nothing, and then those for other ones
% are given by \!\pcol@defcolumn! invoked in \!\pcol@com@switchcolumn!  to 
% invoke \!\pcol@switchenv!|{column|(|*|)|}|(|*|) which then invokes
% \!\switchcolumn!.  Note that the definition
% of non-starred \!\pcol@com@column! has \!\relax!  after the invocatoin of
% \!\pcol@switchenv!  so that \!\@ifnextchar! and \!\@ifstar! to examine the
% existence of `|[|' and `|*|' definitely tell us no even if the body of the
% environment starts with a `|[|' or `|*|'.
% 
%    \begin{macrocode}
\def\pcol@defcolumn{%
  \gdef\pcol@com@column{\pcol@switchenv{column}\relax}%
  \global\@namedef{pcol@com@column*}{\pcol@switchenv{column*}*}}

%    \end{macrocode}
% \end{macro}\end{macro}\end{macro}\end{macro}\end{macro}
% 
% \begin{macro}{\nthcolumn}
% \changes{v1.0}{2011/10/10}
%	{Made \cs{let}-equal to \cs{pcol@com@nthcolumn} for localization.}
% \begin{macro}{\nthcolumn*}
% \changes{v1.0}{2011/10/10}
%	{Made \cs{let}-equal to \cs{pcol@com@nthcolumn*} for localization.}
% \begin{macro}{\pcol@com@nthcolumn}
% \changes{v1.0}{2011/10/10}
%	{Introduced as the implemenatation of \cs{nthcolumn} with the
%	 inhibitation of column-switching in the environment.}
% \begin{macro}{\pcol@com@nthcolumn*}
% \changes{v1.0}{2011/10/10}
%	{Introduced as the implemenatation of \cs{nthcolumn*} with the
%	 inhibitation of column-switching in the environment.}
% \begin{macro}{\leftcolumn}
% \changes{v1.0}{2011/10/10}
%	{Made \cs{let}-equal to \cs{pcol@com@leftcolumn} for localization.}
% \begin{macro}{\leftcolumn*}
% \changes{v1.0}{2011/10/10}
%	{Made \cs{let}-equal to \cs{pcol@com@leftcolumn*} for localization.}
% \begin{macro}{\pcol@com@leftcolumn}
% \changes{v1.0}{2011/10/10}
%	{Introduced as the implemenatation of \cs{leftcolumn} with the
%	 inhibitation of column-switching in the environment.}
% \begin{macro}{\pcol@com@leftcolumn*}
% \changes{v1.0}{2011/10/10}
%	{Introduced as the implemenatation of \cs{leftcolumn*} with the
%	 inhibitation of column-switching in the environment.}
% \begin{macro}{\rightcolumn}
% \changes{v1.0}{2011/10/10}
%	{Made \cs{let}-equal to \cs{pcol@com@rightcolumn} for localization.}
% \begin{macro}{\rightcolumn*}
% \changes{v1.0}{2011/10/10}
%	{Made \cs{let}-equal to \cs{pcol@com@rightcolumn*} for localization.}
% \begin{macro}{\pcol@com@rightcolumn}
% \changes{v1.0}{2011/10/10}
%	{Introduced as the implemenatation of \cs{rightcolumn} with the
%	 inhibitation of column-switching in the environment.}
% \begin{macro}{\pcol@com@rightcolumn*}
% \changes{v1.0}{2011/10/10}
%	{Introduced as the implemenatation of \cs{rightcolumn*} with the
%	 inhibitation of column-switching in the environment.}
% 
% The macros $\!\pcol@com@nthcolumn!(|*|)\arg{d}$,
% \!\pcol@com@leftcolumn!(|*|) and |\pcol@com@right|\~|column|(|*|) are the
% implementations of \elocal{} API macros \!\nthcolumn!(|*|)$\arg{d}$,
% \!\leftcolumn!(|*|) and \!\rightcolumn!(|*|) respectively.  They start
% corresponding environments \Midx{\env{nthcolumn}}, \Midx{\env{leftcolumn}}
% and \Midx{\env{rightcolumn}} simply invoking
% \!\pcol@switchenv!$\Arg{env}$(|*|), where $\arg{env}$ is the name of each
% environment, giving it $d$, 0 and 1 repectively as its optional argument
% for the target column.
% 
%    \begin{macrocode}
\def\pcol@com@nthcolumn#1{\pcol@switchenv{nthcolumn}[#1]\relax}
\@namedef{pcol@com@nthcolumn*}#1{\pcol@switchenv{nthcolumn*}[#1]*}
\def\pcol@com@leftcolumn{\pcol@switchenv{leftcolumn}[0]\relax}
\@namedef{pcol@com@leftcolumn*}{\pcol@switchenv{leftcolumn*}[0]*}
\def\pcol@com@rightcolumn{\pcol@switchenv{rightcolumn}[1]\relax}
\@namedef{pcol@com@rightcolumn*}{\pcol@switchenv{rightcolumn*}[1]*}

%    \end{macrocode}
% \end{macro}\end{macro}\end{macro}\end{macro}
% \end{macro}\end{macro}\end{macro}\end{macro}
% \end{macro}\end{macro}\end{macro}\end{macro}
% 
% \begin{macro}{\pcol@switchenv}
% \changes{v1.0}{2011/10/10}
%	{Introduced to inhibit column-switching in the environment.}
% 
% The macro $\!\pcol@switchenv!\arg{env}$ is invoked from
% $|\pcol@com@|{\cdot}\arg{env}$ where $\arg{env}\in
% \{\env{column}\~(|*|),\env{nthcolumn}(|*|),\env{leftcolumn}(|*|),
% \env{rightcolumn}(|*|)\}$ to invoke \!\switchcolumn! with the arguments
% following $\arg{env}$ given by the invoker macros.  Before invoking
% \!\switchcolumn!, we save it in \!\reserved@a! for the invocation and
% re\!\def!ine it so that it will complain the illegal usage of \cswitch{}
% commands\slash environments in the environment $\arg{env}$ by
% \!\PackageError!.
% 
%    \begin{macrocode}
\def\pcol@switchenv#1{\let\reserved@a\switchcolumn
  \def\switchcolumn{\PackageError{paracol}{%
    Column swicthing commands and environments cannot be used in #1}\@eha}
  \reserved@a}

%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\endcolumn}
% \changes{v1.0}{2011/10/10}
%	{Made \cs{let}-equal to \cs{pcol@com@endcolumn} for localization.}
% \begin{macro}{\endcolumn*}
% \changes{v1.0}{2011/10/10}
%	{Made \cs{let}-equal to \cs{pcol@com@endcolumn*} for localization.}
% \begin{macro}{\pcol@com@endcolumn}
% \changes{v1.0}{2011/10/10}
%	{Introduced as the implemenatation of \cs{endcolumn} with the
%	 globalizatoin of \cs{everypar}.}
% \begin{macro}{\pcol@com@endcolumn*}
% \changes{v1.0}{2011/10/10}
%	{Introduced as the implemenatation of \cs{endcolumn*} with the
%	 globalizatoin of \cs{everypar}.}
% \begin{macro}{\endnthcolumn}
% \changes{v1.0}{2011/10/10}
%	{Made \cs{let}-equal to \cs{pcol@com@endnthcolumn} for localization.}
% \begin{macro}{\endnthcolumn*}
% \changes{v1.0}{2011/10/10}
%	{Made \cs{let}-equal to \cs{pcol@com@endnthcolumn*} for
%	 localization.}
% \begin{macro}{\pcol@com@endnthcolumn}
% \changes{v1.0}{2011/10/10}
%	{Introduced as the implemenatation of \cs{endnthcolumn} with the
%	 globalizatoin of \cs{everypar}.}
% \begin{macro}{\pcol@com@endnthcolumn*}
% \changes{v1.0}{2011/10/10}
%	{Introduced as the implemenatation of \cs{endnthcolumn*} with the
%	 globalizatoin of \cs{everypar}.}
% \begin{macro}{\endleftcolumn}
% \changes{v1.0}{2011/10/10}
%	{Made \cs{let}-equal to \cs{pcol@com@endleftcolumn} for
%	 localization.} 
% \begin{macro}{\endleftcolumn*}
% \changes{v1.0}{2011/10/10}
%	{Made \cs{let}-equal to \cs{pcol@com@endleftcolumn*} for
%	 localization.}
% \begin{macro}{\pcol@com@endleftcolumn}
% \changes{v1.0}{2011/10/10}
%	{Introduced as the implemenatation of \cs{endleftcolumn} with the
%	 globalizatoin of \cs{everypar}.}
% \begin{macro}{\pcol@com@endleftcolumn*}
% \changes{v1.0}{2011/10/10}
%	{Introduced as the implemenatation of \cs{endleftcolumn*} with the
%	 globalizatoin of \cs{everypar}.}
% \begin{macro}{\endrightcolumn}
% \changes{v1.0}{2011/10/10}
%	{Made \cs{let}-equal to \cs{pcol@com@endrightcolumn} for
%	 localization.}
% \begin{macro}{\endrightcolumn*}
% \changes{v1.0}{2011/10/10}
%	{Made \cs{let}-equal to \cs{pcol@com@endrightcolumn*} for
%	 localization.}
% \begin{macro}{\pcol@com@endrightcolumn}
% \changes{v1.0}{2011/10/10}
%	{Introduced as the implemenatation of \cs{endrightcolumn} with the
%	 globalizatoin of \cs{everypar}.}
% \begin{macro}{\pcol@com@endrightcolumn*}
% \changes{v1.0}{2011/10/10}
%	{Introduced as the implemenatation of \cs{endrightcolumn*} with the
%	 globalizatoin of \cs{everypar}.}
% 
% The macro \!\pcol@com@endcolumn! is the implementation of the \elocal{}
% API macro \!\endcolumn! to close \env{column} environment.  The macro
% makes it sure we are in vertical mode by \!\pcol@par! and \!\global!ize
% \!\everypar! so that it is saved in $\cc_c(\ep)$ of the current column
% $c$ on the switch to another column.  The macro also gives the commmon
% definition of \!\pcol@com@endcolumn*!  for \!\endcolumn*!,
% \!\pcol@com@endnthcolumn!(|*|) for \!\endnthcolumn!(|*|),
% \!\pcol@com@endleftcolumn!(|*|) for \!\endleftcolumn!(|*|), and
% \!\pcol@com@endrightcolumn!(|*|) for \!\endrightcolumn!(|*|).
% 
%    \begin{macrocode}
\def\pcol@com@endcolumn{\pcol@par
  \expandafter\global\expandafter\everypar\expandafter{\the\everypar}}
\expandafter\let\csname pcol@com@endcolumn*\endcsname\pcol@com@endcolumn
\let\pcol@com@endnthcolumn\pcol@com@endcolumn
\expandafter\let\csname pcol@com@endnthcolumn*\endcsname\pcol@com@endcolumn
\let\pcol@com@endleftcolumn\pcol@com@endcolumn
\expandafter\let\csname pcol@com@endleftcolumn*\endcsname\pcol@com@endcolumn
\let\pcol@com@endrightcolumn\pcol@com@endcolumn
\expandafter\let\csname pcol@com@endrightcolumn*\endcsname\pcol@com@endcolumn

%    \end{macrocode}
% \end{macro}\end{macro}\end{macro}\end{macro}
% \end{macro}\end{macro}\end{macro}\end{macro}
% \end{macro}\end{macro}\end{macro}\end{macro}
% \end{macro}\end{macro}\end{macro}\end{macro}
% 
% 
% 
% \section{Disabing \cs{addcontentsline}}
% \label{sec:imp-aconly}
% 
% \begin{macro}{\addcontentsonly}
% \changes{v1.0}{2011/10/10}
%	{Introduced for disabling \cs{addcontentsline}.}
% \begin{macro}{\pcol@aconly}
% \changes{v1.0}{2011/10/10}
%	{Introduced for disabling \cs{addcontentsline}.}
% 
% The API macro $\!\addcontentsonly!\arg{t}\arg{c}$ makes the type $t$
% contents file written by commands appearing only in the column $c$.  The
% macro simply add the pair $\<t,c\>$ to the list $\Uidx\T=\!\pcol@aconly!$
% being empty at initial, after confirming we know the type $t$, one of
% |toc|, |lof| and |lot| so far, by the fact $|\pcol@ac@def|{\cdot}t$ is
% defined, or abort execution by \!\PackageError!.
% 
%    \begin{macrocode}
%% Disabling \addcontentsline

\def\addcontentsonly#1#2{%
  \@ifundefined{pcol@ac@def@#1}
    {\PackageError{paracol}{Unknown contents type #1}\@eha}\relax
  \@cons\pcol@aconly{{#1}{#2}}}
\gdef\pcol@aconly{}

%    \end{macrocode}
% \end{macro}\end{macro}
% 
% \begin{macro}{\pcol@aconlyelt}
% \changes{v1.0}{2011/10/10}
%	{Introduced for disabling \cs{addcontentsline}.}
% 
% The macro $\!\pcol@aconlyelt!\arg{t_d}\arg{d}$ is invoked solely in
% \!\pcol@switchcol!  for the \cswitch{} to column $c$, and is applied to
% each $\<t_d,d\>\in\T$ to enable \!\addcontentsline! for $t$ if $d=c$ by
% the invocation of $|\pcol@ac@def@|{\cdot}t$ with an argument |enable|, or
% to disable if $d\neq c$ with |disable|.
% 
%    \begin{macrocode}
\def\pcol@aconlyelt#1#2{%
  \ifnum#2=\pcol@currcol \@nameuse{pcol@ac@def@#1}{enable}%
  \else \@nameuse{pcol@ac@def@#1}{disable}%
  \fi}
%    \end{macrocode}
% \end{macro}
% 
% \begin{macro}{\pcol@gobblethree}
% \changes{v1.0}{2011/10/10}
%	{Introduced for disabling \cs{addcontentsline}.}
% \begin{macro}{\pcol@addcontentsline}
% \changes{v1.0}{2011/10/10}
%	{Introduced for disabling \cs{addcontentsline}.}
% 
% \hfuzz0.39pt
% The macro $\!\pcol@gobblethree!\arg{file}\arg{sec}\arg{entry}$ is used in
% \!\pcol@ac@disable@toc! and \!\pcol@ac@caption! to make
% \!\addcontentsline! \!\let!-equal to this macro, which does nothing but
% discarding three arguments, for disabling.  The macro
% \!\pcol@addcontentsline! is the \LaTeX's original \!\addcontentsline! and
% is used in the macros mentioned above to let \!\addcontentsline! act as
% original.
% 
%    \begin{macrocode}
\def\pcol@gobblethree#1#2#3{}
\let\pcol@addcontentsline\addcontentsline

%    \end{macrocode}
% \end{macro}\end{macro}
% 
% \begin{macro}{\pcol@ac@def@toc}
% \changes{v1.0}{2011/10/10}
%	{Introduced for disabling \cs{addcontentsline}.}
% \begin{macro}{\pcol@ac@enable@toc}
% \changes{v1.0}{2011/10/10}
%	{Introduced for disabling \cs{addcontentsline}.}
% \begin{macro}{\pcol@ac@disable@toc}
% \changes{v1.0}{2011/10/10}
%	{Introduced for disabling \cs{addcontentsline}.}
% 
% The macro $\!\pcol@ac@def@toc!\arg{eord}$ is invoked solely in
% $\!\pcol@aconlyelt!|{toc}|\arg{c}$ to enable or disable
% \!\addcontentsline! according to $\arg{eord}$ by making \!\@sect!
% \!\let!-equal to \!\pcol@ac@enable@toc! which is the \LaTeX's original
% \!\@sect!, or to \!\pcol@ac@disable@toc! respectively.  The macro
% $\!\pcol@ac@disable@toc!
% \<a_1\>\<a_2\>\<a_3\>\<a_4\>\<a_5\>\<a_6\>|[|\<a_7\>|]|\<a_8\>$ at first
% disables \!\addcontentsline! by making it \!\let!-equal to
% \!\pcol@gobblethree!, then invokes the original \!\@sect! saved in
% \!\pcol@ac@enable@toc! ginving it all arguments $a_1$ to $a_8$, and
% finally enables it by making it \!\let!-equal to \!\pcol@addcontentsline!.
% Note that the argument $a_7$ is surrounded by |{| and |}| on the
% invocation of \!\@sect! to conceal `|]|' in $a_7$.
% 
%    \begin{macrocode}
\def\pcol@ac@def@toc#1{%
  \expandafter\let\expandafter\@sect\csname pcol@ac@#1@toc\endcsname}
\let\pcol@ac@enable@toc\@sect
\def\pcol@ac@disable@toc#1#2#3#4#5#6[#7]#8{%
  \let\addcontentsline\pcol@gobblethree
  \pcol@ac@enable@toc{#1}{#2}{#3}{#4}{#5}{#6}[{#7}]{#8}%
  \let\addcontentsline\pcol@addcontentsline}

%    \end{macrocode}
% \end{macro}\end{macro}\end{macro}
% 
% \begin{macro}{\pcol@ac@def@lof}
% \changes{v1.0}{2011/10/10}
%	{Introduced for disabling \cs{addcontentsline}.}
% \begin{macro}{\pcol@ac@def@lot}
% \changes{v1.0}{2011/10/10}
%	{Introduced for disabling \cs{addcontentsline}.}
% \begin{macro}{\pcol@ac@caption@enable}
% \changes{v1.0}{2011/10/10}
%	{Introduced for disabling \cs{addcontentsline}.}
% \begin{macro}{\pcol@ac@caption@disable}
% \changes{v1.0}{2011/10/10}
%	{Introduced for disabling \cs{addcontentsline}.}
% \begin{macro}{\pcol@ac@caption@def}
% \changes{v1.0}{2011/10/10}
%	{Introduced for disabling \cs{addcontentsline}.}
% \begin{macro}{\pcol@ac@caption@if@lof}
% \changes{v1.0}{2011/10/10}
%	{Introduced for disabling \cs{addcontentsline}.}
% \begin{macro}{\pcol@ac@caption@if@lot}
% \changes{v1.0}{2011/10/10}
%	{Introduced for disabling \cs{addcontentsline}.}
% 
% The macro $\!\pcol@ac@def@lof!\arg{eord}$ and
% $\!\pcol@ac@def@lot!\arg{eord}$ are invoked solely in
% $\!\pcol@aconlyelt!\<t_c\>\<c\>$ when $t_c$ is |lof| or |lot|
% respectively.  They invoke \!\pcol@ac@caption@enable!$\<t\>$ or
% $\!\pcol@ac@caption@disable!\<t\>$ according to $\arg{eord}$, and then
% these macros invoke $\!\pcol@ac@caption@def!\<s\>\<t\>$ where
% $s=\!\@tempswatrue!$ or $s=\!\@tempswafalse!$ respectievely to let
% $\!\@caption!=\!\pcol@ac@caption!$ and $|\pcol@ac@caption@if@|{\cdot}t=s$
% which are \!\let!-equal to \!\@tempswatrue! in default.  That is,
% $|\pcol@ac@catption@if@|{\cdot}t$ lets $\CSIndex{if@tempswa}={}\true$ iff
% \!\addcontentsline! for $t$ is to be enable.
% 
%    \begin{macrocode}
\def\pcol@ac@def@lof#1{\@nameuse{pcol@ac@caption@#1}{lof}}
\def\pcol@ac@def@lot#1{\@nameuse{pcol@ac@caption@#1}{lot}}
\def\pcol@ac@caption@enable{\pcol@ac@caption@def\@tempswatrue}
\def\pcol@ac@caption@disable{\pcol@ac@caption@def\@tempswafalse}
\def\pcol@ac@caption@def#1#2{\let\@caption\pcol@ac@caption
 \expandafter\let\csname pcol@ac@caption@if@#2\endcsname#1}
\let\pcol@ac@caption@if@lof\@tempswatrue
\let\pcol@ac@caption@if@lot\@tempswatrue
%    \end{macrocode}
% \end{macro}\end{macro}\end{macro}\end{macro}
% \end{macro}\end{macro}\end{macro}
% 
% \begin{macro}{\pcol@ac@caption}
% \changes{v1.0}{2011/10/10}
%	{Introduced for disabling \cs{addcontentsline}.}
% \begin{macro}{\pcol@ac@caption@latex}
% \changes{v1.0}{2011/10/10}
%	{Introduced for disabling \cs{addcontentsline}.}
% 
% The macro $\!\pcol@ac@caption!\arg{type}|[|\arg{lcap}|]|\<cap\>$ is made
% \!\let!-equal to \!\@caption! by \!\pcol@ac@caption@def! to do what
% \!\@caption! do but with enabling\slash disabling \!\addcontentsline!.  At
% first, it invokes $|\pcol@ac@cation@if@|{\cdot}t$ where
% $t=|\ext@|{\cdot}\arg{type}$
% 
% \SpecialIndex{\ext@figure}\SpecialIndex{\ext@table}
% 
% to let \CSIndex{if@tempswa} be $\true$ or $\false$ according to the
% enable\slash disable status of $t$.  Then, after letting
% $\!\addcontentsline!=\!\pcol@gobblethree!$ for disabing if $\false$, we
% invoke \!\pcol@ac@caption@latex!, being the \LaTeX's orignial \!\@caption!,
% giving all three arguments of \!\pcol@ac@caption! itself surrounding
% $\arg{lcap}$ with |{| and |}| for the concealment of `|]|'.  Finally, we
% let $\!\addcontentsline!=\!\pcol@addcontentsline!$ so that other macros
% uses it with its original definition.
% 
%    \begin{macrocode}
\long\def\pcol@ac@caption#1[#2]#3{%
  \@nameuse{pcol@ac@caption@if@\@nameuse{ext@#1}}%
  \if@tempswa\else \let\addcontentsline\pcol@gobblethree \fi
  \pcol@ac@caption@latex{#1}[{#2}]{#3}%
  \let\addcontentsline\pcol@addcontentsline}
\let\pcol@ac@caption@latex\@caption

%    \end{macrocode}
% \end{macro}\end{macro}
% 
% 
% 
% \section{Page Flushing Commands}
% \label{sec:imp-flush}
% 
% \begin{macro}{\flushpage}
% \changes{v1.0}{2011/10/10}
%	{Made \cs{let}-equal to \cs{pcol@com@flushpage} for
%	 localization.}
% \begin{macro}{\pcol@com@flushpage}
% \changes{v1.0}{2011/10/10}
%	{Introduced as the implemenatation of \cs{flushpage} with the
%	 replacement of \cs{par} with \cs{pcol@par}.}
% \begin{macro}{\clearpage}
% \changes{v1.0}{2011/10/10}
%	{Made \cs{let}-equal to \cs{pcol@com@clearpage} for
%	 localization.}
% \begin{macro}{\pcol@com@clearpage}
% \changes{v1.0}{2011/10/10}
%	{Introduced as the implemenatation of \cs{clearpage} with the
%	 replacement of \cs{par} with \cs{pcol@par}.}
% 
% The macros \!\pcol@com@flushpage! and \!\pcol@com@clearpage! are the
% implementations of \elocal{} API macro \!\flushpage! and \!\clearpage!
% respectively.  They have a common structure in which we at first invoke
% \!\pcol@par! to make it sure to be in vertical mode, let
% $\!\pcol@nextcol!=\!\pcol@currcol!$ to stay in the current column, and then
% make an \!\output! request by \!\pcol@invokeoutput! with \!\penalty! being
% \!\pcol@op@flush! or \!\pcol@op@clear! according to the commands.
% 
%    \begin{macrocode}
%% Page Flushing Commands

\def\pcol@com@flushpage{\pcol@par
  \pcol@nextcol\pcol@currcol
  \pcol@invokeoutput\pcol@op@flush}
\def\pcol@com@clearpage{\pcol@par
  \pcol@nextcol\pcol@currcol
  \pcol@invokeoutput\pcol@op@clear}

%    \end{macrocode}
% \end{macro}\end{macro}\end{macro}\end{macro}
% 
% 
% 
% \section{Closing Environment}
% \label{sec:imp-end}
% 
% \begin{macro}{\endparacol}
% \changes{v1.0}{2011/10/10}
%	{Replace \cs{par} with \cs{pcol@par}.}
% 
% The macro \!\endparacol! is invoked from \Endparacol{} to close
% \env{paracol} environment.  After making it sure to be in vertical mode by
% \!\pcol@par!, we switch to the column 0 by \!\pcol@switchcol! to let
% \lcounter{} have the values for the column 0 so that they are referred to
% outside the environment.  Then we make an \!\output! request by
% \!\pcol@invokeoutput! with $\!\penalty!=\!\pcol@op@end!$.  Next, we let
% \!\columnwidth!, \!\hsize! and \!\linewidth! commonly be \!\textwidth!
% for single-column typesetting and also let
% $\CSIndex{if@twocolumn}=\false$.  Finally, we let
% $\!\topskip!=\!\pcol@topskip!$ to make it sure that the parameter has the
% value used outside in \env{paracol} environment.
% 
%    \begin{macrocode}
%% Closing Environment

\def\endparacol{\pcol@par
  \pcol@nextcol\z@ \pcol@switchcol
  \pcol@invokeoutput\pcol@op@end
  \global\columnwidth\textwidth
  \global\hsize\columnwidth
  \global\linewidth\columnwidth
  \global\@twocolumnfalse
  \global\topskip\pcol@topskip}
%    \end{macrocode}
% \end{macro}
%\iffalse
%</paracol>
%\fi
\endinput
